// pages/index/index.js
Page({
  data: {
    // 用户能量（从服务器获取，不使用硬编码）
    userEnergy: 0,

    // 用户信息
    userInfo: {
      userId: null,
      nickname: '',
      avatarUrl: ''
    },

    // 当前活跃的标签页
    activeTab: 'faceSwap',

    // 模特图片
    modelImage: 'https://ceshi-1337249743.cos.ap-beijing.myqcloud.com/uploads/avatar/2025/08/03/avatar_1754230169473_a3a3222f.png',
    // 初始模特图片（用于重置）
    initialModelImage: 'https://ceshi-1337249743.cos.ap-beijing.myqcloud.com/uploads/avatar/2025/08/03/avatar_1754230169473_a3a3222f.png',

    // 当前背景
    currentBackground: '',

    // 当前穿着的服装
    currentClothing: null,
    
    // 当前选中的商品（用于展示试穿按钮）
    selectedProduct: null,

    // 内容区域高度和展开状态
    contentHeight: 300,
    contentExpanded: false,

    // 生日输入
    birthday: '',

    // 运势结果
    fortuneResult: '',

    // 当前显示的商品列表
    currentProducts: [],

    // 推荐商品（从API获取）
    recommendedProducts: [],

    // 运势相关数据
    constellation: '',
    fortuneKeywords: [],
    colorKeywords: [],
    styleKeywords: [],
    recommendationId: null,

    // 生日管理状态
    userBirthdaySet: false,
    isSettingBirthday: false,
    isGettingFortune: false,

    // 当前日期（用于picker的end属性）
    currentDate: '',

    // 全部商品（从API加载）
    allProducts: [],
    allProductsLoading: false,
    allProductsLoaded: false,

    // 商品分类和筛选
    productCategories: [],
    selectedProductCategory: '',
    selectedProductCategoryId: null,
    filteredProducts: [],



    // 分页
    currentProductPage: 1,
    hasMoreProducts: true,
    loadingMoreProducts: false,

    // 衣橱分类
    wardrobeCategories: [],
    wardrobeCategoriesLoading: false,
    wardrobeCategoriesLoaded: false,

    // 当前选中的分类
    selectedCategory: 0,

    // 衣橱商品
    wardrobeItems: [],
    wardrobeItemsLoading: false,
    wardrobeItemsLoaded: false,

    // 当前显示的衣橱商品
    currentWardrobeItems: [],

    // 总衣橱商品数量
    totalWardrobeCount: 0,

    // 衣橱分页
    wardrobePage: 1,
    wardrobePageSize: 20,
    hasMoreWardrobeItems: true,

    // 模态框状态
    showMoveModal: false,
    showCategoryModal: false,
    showEditCategoryModal: false,

    // 商品移动相关
    currentMoveProduct: null,
    selectedMoveCategory: null,

    // 删除确认相关
    showDeleteConfirm: false,
    deleteTargetProduct: null,
    deleteTargetSection: null,

    // 分类管理相关
    newCategoryName: '',
    editCategoryName: '',
    currentEditCategory: null,

    // 背景列表（从API加载）
    backgroundList: [],
    backgroundListLoading: false,
    backgroundListLoaded: false,

    // 脸部素材库（从API加载）
    faceList: [],
    faceMaterialsLoading: false,
    faceMaterialsLoaded: false,

    // 换脸相关状态
    selectedFace: null,
    selectedFaceImage: null, // 选中的脸部素材图片URL
    customFaceImage: null, // 上传到COS的图片URL
    customFaceThumbnail: null, // 本地缩略图用于预览
    
    // 我的形象弹窗控制
    showAvatarModal: false,
    
    // 临时选择状态（用于弹窗中的预选择）
    tempSelectedFace: null,
    tempSelectedFaceName: '',
    tempCustomFaceImage: false,
    customFaceMaterialId: null, // 用户上传人脸的真实素材ID
    fusionDegree: 80, // 融合程度 0-100
    showFaceMaterialsModal: false, // 控制我的形象弹窗显示

    // 换背景相关状态
    selectedBackground: null,
    customBackgroundImage: null, // 上传到COS的背景图片URL
    customBackgroundThumbnail: null, // 本地缩略图用于预览
    currentBackground: '', // 当前显示的背景图片URL

    // AI处理状态
    aiProcessing: false,
    aiLoading: false, // 兼容性字段
    aiProgress: 0,
    aiOperationType: 'tryon', // 'tryon' | 'background' | 'face'

    // 衣柜区域开关状态（内嵌版本）
    openSections: {
      tops: false,        // 上衣
      bottoms: false,     // 裤子裙子
      outerwear: false,   // 外套
      accessories: false, // 配饰
      shoes: false,       // 鞋子
      custom: false       // 自定义
    },

    // 各区域的商品（内嵌版本）
    sectionProducts: {
      tops: [],
      bottoms: [],
      outerwear: [],
      accessories: [],
      shoes: [],
      custom: []
    },

    // 衣橱加载状态
    wardrobeLoading: false,

    // 添加衣物弹窗状态
    showAddClothesModal: false,
    selectedTargetSection: '',
    selectedProducts: {},
    addClothesMethod: 'favorite', // 'favorite' 或 'upload'

    // 自定义衣物上传
    customClothes: {
      name: '',
      image: ''
    },
    customClothesUploading: false,

    // 衣柜商品存储（按分区存储商品ID）
    wardrobeSectionItems: {
      tops: [],
      bottoms: [],
      outerwear: [],
      accessories: [],
      shoes: [],
      custom: []
    }
  },

  onLoad() {
    console.log('首页加载完成');

    // 初始化数据（不强制要求登录）
    this.initializeData();

    // 从缓存恢复上传的头像
    this.loadUploadedAvatarFromCache();

    // 检查并同步登录状态
    this.syncLoginStatus();

    // 检查登录状态，如果已登录则加载用户数据
    const app = getApp()
    if (app.globalData.isLogin) {
      this.loadUserEnergy();
      this.refreshUserInfo();
    } else {
      // 未登录状态下设置默认算力
      this.setData({
        userEnergy: 100
      });
    }
  },

  onShow() {
    console.log('首页显示');
    
    // 每次显示时都检查登录状态
    this.syncLoginStatus();

    // 每次页面显示时刷新算力值
    this.loadUserEnergy();

    // 检查推荐商品的收藏状态（如果有推荐商品）
    if (this.data.recommendedProducts && this.data.recommendedProducts.length > 0) {
      this.checkRecommendedProductsFavoriteStatus(this.data.recommendedProducts);
    }

    // 检查全部商品的收藏状态（如果有商品）
    if (this.data.allProducts && this.data.allProducts.length > 0) {
      this.checkProductsFavoriteStatus(this.data.allProducts);
    }

    // 如果背景素材还未加载，尝试加载
    if (!this.data.backgroundListLoaded && !this.data.backgroundListLoading) {
      this.loadBackgroundMaterials();
    }

    // 如果脸部素材还未加载，尝试加载
    if (!this.data.faceMaterialsLoaded && !this.data.faceMaterialsLoading) {
      this.loadFaceMaterials();
    }

    // 如果衣橱数据还未加载，尝试加载
    if (!this.data.wardrobeCategoriesLoaded && !this.data.wardrobeCategoriesLoading) {
      this.loadWardrobeCategories();
    }
    if (!this.data.wardrobeItemsLoaded && !this.data.wardrobeItemsLoading) {
      this.loadWardrobeItems();
    }

    // 如果切换到衣橱tab，组织衣柜商品
    if (this.data.activeTab === 'wardrobe') {
      console.log('🔄 切换到衣橱tab，检查并刷新数据');

      // 强制刷新衣橱数据，确保显示最新的收藏商品
      if (!this.data.wardrobeItemsLoading) {
        this.setData({
          wardrobeItemsLoaded: false
        });
        this.loadWardrobeItems().then(() => {
          this.organizeWardrobeSectionProducts();
        });
      } else {
        this.organizeWardrobeSectionProducts();
      }
    }
  },

  // 加载用户算力
  loadUserEnergy() {
    const app = getApp();
    const userInfo = app.globalData.userInfo;

    if (userInfo && userInfo.tokenBalance !== undefined) {
      this.setData({
        userEnergy: userInfo.tokenBalance
      });
      // 同步更新全局算力值
      app.globalData.userEnergy = userInfo.tokenBalance;
      console.log('从用户信息加载算力值', userInfo.tokenBalance);
    } else {
      // 如果没有用户信息，使用默认值
      this.setData({
        userEnergy: 0
      });
      app.globalData.userEnergy = 0;
      console.log('用户未登录，算力值设为0');
    }
  },

  // 刷新用户信息（从服务器获取最新数据）
  refreshUserInfo() {
    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      console.log('用户未登录，无法刷新用户信息');
      return;
    }

    console.log('🔄 刷新用户信息...');

    wx.request({
      url: `${app.globalData.baseUrl}/users/profile`,
      method: 'GET',
      header: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      },
      success: (res) => {
        console.log('📥 用户信息响应:', res);

        if (res.statusCode === 200 && res.data.code === 1) {
          const userInfo = res.data.data;

          // 更新全局用户信息
          app.globalData.userInfo = userInfo;
          wx.setStorageSync('userInfo', userInfo);

          // 更新算力显示和用户信息显示
          this.setData({
            userEnergy: userInfo.tokenBalance || 0,
            userInfo: {
              userId: userInfo.userId,
              nickname: userInfo.nickname || '微信用户',
              avatarUrl: userInfo.avatarUrl || ''
            }
          });

          // 同步更新全局算力值
          app.globalData.userEnergy = userInfo.tokenBalance || 0;

          console.log('✅用户信息刷新成功', {
            userId: userInfo.userId,
            nickname: userInfo.nickname,
            tokenBalance: userInfo.tokenBalance
          });
        } else {
          console.error('?获取用户信息失败:', res.data);
        }
      },
      fail: (error) => {
        console.error('?刷新用户信息网络请求失败:', error);
      }
    });
  },

  // 同步登录状态（从Storage恢复到GlobalData）
  syncLoginStatus() {
    const app = getApp();
    const storageToken = wx.getStorageSync('token');
    const storageUserInfo = wx.getStorageSync('userInfo');
    
    console.log('🔄 同步登录状态');
    console.log('Storage Token:', storageToken ? '存在' : '不存在');
    console.log('Storage UserInfo:', storageUserInfo ? '存在' : '不存在');
    console.log('GlobalData Token:', app.globalData.token ? '存在' : '不存在');
    
    // 如果Storage中有token但GlobalData中没有，则同步
    if (storageToken && !app.globalData.token) {
      console.log('✅ 从Storage恢复登录状态到GlobalData');
      app.globalData.isLogin = true;
      app.globalData.token = storageToken;
      app.globalData.userInfo = storageUserInfo;

      // 同步用户信息到页面显示
      if (storageUserInfo) {
        this.setData({
          userInfo: {
            userId: storageUserInfo.userId,
            nickname: storageUserInfo.nickname || '微信用户',
            avatarUrl: storageUserInfo.avatarUrl || ''
          }
        });
      }
    }
    // 如果Storage中没有token但GlobalData中有，则清空GlobalData
    else if (!storageToken && app.globalData.token) {
      console.log('🧹 清空过期的GlobalData登录状态');
      app.globalData.isLogin = false;
      app.globalData.token = '';
      app.globalData.userInfo = null;

      // 清空页面用户信息显示
      this.setData({
        userInfo: {
          userId: null,
          nickname: '',
          avatarUrl: ''
        }
      });
    }
  },

  // 初始化数据
  initializeData() {
    // 设置当前日期（用于picker的end属性）
    const today = new Date();
    const currentDate = today.getFullYear() + '-' +
                       String(today.getMonth() + 1).padStart(2, '0') + '-' +
                       String(today.getDate()).padStart(2, '0');

    this.setData({
      modelImage: 'https://ceshi-1337249743.cos.ap-beijing.myqcloud.com/uploads/avatar/2025/08/03/avatar_1754230169473_a3a3222f.png',
      initialModelImage: 'https://ceshi-1337249743.cos.ap-beijing.myqcloud.com/uploads/avatar/2025/08/03/avatar_1754230169473_a3a3222f.png',
      currentDate: currentDate
    });

    console.log('📅 设置picker最大日期', currentDate);

    // 模拟从API获取商品数据
    this.loadProductsFromAPI();

    // 加载全部商品数据
    this.loadAllProducts();

    // 模拟从API获取脸部素材
    this.loadFaceMaterials();

    // 从API加载背景素材
    this.loadBackgroundMaterials();

    // 加载衣橱数据
    this.loadWardrobeCategories();
    this.loadWardrobeItems();

    // 检查用户是否已设置生日
    this.checkUserBirthday();
  },

  // 检查用户生日
  checkUserBirthday() {
    const app = getApp();
    const userInfo = app.globalData.userInfo;

    if (userInfo && userInfo.birthday) {
      this.setData({
        birthday: userInfo.birthday,
        userBirthdaySet: true
      });
      console.log('✅用户已设置生日', userInfo.birthday);

      // 自动获取今日运势
      this.getFortuneRecommendation();
    } else {
      this.setData({
        userBirthdaySet: false,
        birthday: ''
      });
      console.log('⚠️ 用户未设置生日，需要手动输入');
    }
  },

  // 从外部API加载商品数据
  loadProductsFromAPI() {
    // 这里应该调用真实的API: https://xryshop.xryai.cn/api/product/spu/merchant/1
    // 现在使用模拟数据
    console.log('加载商品数据...');
  },

  // 加载全部商品数据（直接调用外部API）
  loadAllProducts() {
    // 如果已经加载过，不重复加载
    if (this.data.allProductsLoaded) {
      console.log('📦 全部商品已加载，跳过重复请求');
      return;
    }

    this.setData({ allProductsLoading: true });

    console.log('🛍️开始加载全部商品（直接调用外部API）..');
    
    // 使用新的API接口 - 正确路径：/product/spu/merchant/{id}
    const apiUrl = 'https://xry.zysemtime.com/api/product/spu/merchant/1';
    console.log('🔗 API地址:', apiUrl);
    console.log('📋 请求参数:', { page: 1, limit: 30 });
    console.log('✅ API已验证可用，返回18个商品数据');

    wx.request({
      url: apiUrl,
      method: 'GET',
      data: {
        page: 1,
        limit: 30
      },
      success: (response) => {
        console.log('📥 外部商品API响应:', response);

        if (response.statusCode === 200 && response.data.status === 200) {
          const products = response.data.data.list || [];
          console.log('📦 原始商品数据:', products.length, '个商品');
          console.log('🔍 第一个商品数据示例:', products[0]);
          
          if (products.length === 0) {
            console.log('⚠️ API返回商品列表为空');
            this.setData({ 
              allProductsLoading: false,
              allProducts: [],
              filteredProducts: []
            });
            return;
          }

          // 转换数据格式以匹配现有的UI结构
          const processedProducts = products
            .filter(product => {
              // 只要有商品数据就显示，不过滤下架状态
              console.log(`✅ 商品${product.product_id}加载成功`);
              return true;
            })
            .map(product => {
              const productName = product.store_name || '';
              const categoryName = this.analyzeProductCategory(productName);
              const clothesType = this.analyzeClothesType(productName);

              return {
                // 基础信息
                id: product.product_id,
                productId: product.product_id,
                name: productName,
                productName: productName, // 兼容字段

                // 图片信息
                image: product.image,
                productImage: product.image, // 兼容字段
                images: Array.isArray(product.slider_image) ? product.slider_image : [product.image],

                // 价格信息
                price: parseFloat(product.price) || 0,
                productPrice: parseFloat(product.price) || 0, // 兼容字段
                originalPrice: parseFloat(product.ot_price) || 0,

                // 分类信息
                categoryId: product.cate_id,
                categoryName: categoryName,
                category: categoryName, // 兼容字段
                clothesType: clothesType,

                // 状态信息
                favorited: false, // 默认未收藏，后续检查收藏状态
                isFavorite: false, // 兼容字段
                tryOnLoading: false,
                favoriteLoading: false,

                // 商品属性
                stock: product.stock || 0,
                sales: product.sales || 0,
                rating: parseFloat(product.rate) || 0,
                isNew: product.is_new === 1,
                isHot: product.is_hot === 1,
                isRecommended: product.is_good === 1,
                
                // 统计信息（用于UI显示）
                favoriteCount: product.care_count || Math.floor(Math.random() * 50) + 5,
                viewCount: product.browse || Math.floor(Math.random() * 100) + 10,

                // 描述信息
                description: product.store_info || '',
                keyword: product.keyword || '',
                unitName: product.unit_name || '件',

                // 商家信息
                merchant: product.merchant || {},
                merchantName: product.merchant ? product.merchant.mer_name : '',
                merchantAvatar: product.merchant ? product.merchant.mer_avatar : '',

                // 链接信息
                originalUrl: product.original_url || null,
                externalLink: this.generateProductLink({
                  productName: productName,
                  name: productName,
                  image: product.image,
                  productId: product.product_id
                })
              };
            });

          // 生成商品分类
          const productCategories = this.generateProductCategories(processedProducts);

          // 检查收藏状态
          this.checkProductsFavoriteStatus(processedProducts);

          this.setData({
            allProducts: processedProducts,
            filteredProducts: this.filterProductsByCategory(processedProducts, this.data.selectedProductCategory),
            productCategories: productCategories,
            allProductsLoaded: true,
            allProductsLoading: false,
            hasMoreProducts: false // 外部API一次返回所有数据
          });

          console.log('✅全部商品加载成功:', processedProducts.length, '件商品（包含所有状态），', productCategories.length, '个分类');
          console.log('📦 商品数据详情:', processedProducts.slice(0, 3)); // 显示前3个商品的详细信息
          console.log('🏷️分类数据:', productCategories);
          console.log('📊 当前显示商品数据:', this.filterProductsByCategory(processedProducts, this.data.selectedProductCategory).length, '件');
        } else {
          console.error('❌获取全部商品失败:', response.data.message);
          this.setData({ allProductsLoading: false });
          wx.showToast({
            title: response.data.message || '商品加载失败',
            icon: 'none',
            duration: 2000
          });
        }
      },
      fail: (error) => {
        console.error('❌加载全部商品网络请求失败:', error);
        this.setData({ allProductsLoading: false });
        wx.showToast({
          title: '网络请求失败',
          icon: 'none',
          duration: 2000
        });
      }
    });
  },

  // 从API加载脸部素材
  async loadFaceMaterials() {
    if (this.data.faceMaterialsLoading || this.data.faceMaterialsLoaded) {
      console.log('脸部素材已在加载中或已加载');
      return;
    }

    console.log('👤 开始加载脸部素材');

    this.setData({
      faceMaterialsLoading: true
    });

    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      console.log('⚠️ 未登录，跳过脸部素材加载');
      this.setData({
        faceMaterialsLoading: false
      });
      return;
    }

    try {
      const result = await this.callFaceMaterialsAPI(token);

      if (result && result.code === 1 && result.data && result.data.rows) {
        // 转换API数据格式为小程序需要的格式
        const faceList = result.data.rows
          .filter(item => item.status === 1) // 只显示启用的素材
          .map(item => ({
            id: item.materialId,
            name: item.materialName,
            imageUrl: item.imageUrl,
            thumbnailUrl: item.thumbnailUrl || item.imageUrl,
            tags: item.tags || [],
            modelId: item.modelId,
            projectId: item.projectId,
            sortOrder: item.sortOrder || 0
          }))
          .sort((a, b) => a.sortOrder - b.sortOrder); // 按排序顺序排列
        this.setData({
          faceList: faceList,
          faceMaterialsLoading: false,
          faceMaterialsLoaded: true,
          // 默认选中第一张图片
          selectedFace: faceList.length > 0 ? faceList[0].id : null
        });

        console.log('✅脸部素材加载成功，数量', faceList.length);
        if (faceList.length > 0) {
          console.log('✅默认选中第一张脸部素材:', faceList[0].name);
        }
      } else {
        throw new Error(result && result.msg ? result.msg : '获取脸部素材失败');
      }
    } catch (error) {
      console.error('?加载脸部素材失败:', error);

      this.setData({
        faceMaterialsLoading: false
      });

      // 如果API失败，使用默认脸部素材
      this.setDefaultFaceMaterials();
    }
  },

  // 设置默认脸部素材（API失败时的备用方案）
  setDefaultFaceMaterials() {
    console.log('🔄 使用默认脸部素材');

    // 暂时不设置默认素材，强制从API获取
    console.log('⚠️ 脸部素材API失败，无法使用换脸功能');

    this.setData({
      faceList: [],
      faceMaterialsLoaded: true
    });

    wx.showToast({
      title: '无法加载脸部素材，请检查网络',
      icon: 'none',
      duration: 3000
    });
  },

  // 调用脸部素材API
  callFaceMaterialsAPI(token) {
    const app = getApp();
    return new Promise((resolve, reject) => {
      console.log('🔄 调用脸部素材API');
      console.log('API地址:', `${app.globalData.baseUrl}/materials/faces`);

      wx.request({
        url: `${app.globalData.baseUrl}/materials/faces`,
        method: 'GET',
        timeout: 30000,
        header: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`
        },
        data: {
          status: 1, // 只获取启用的素材
          pageSize: 50 // 获取足够多的素材
        },
        success: (res) => {
          console.log('📥 脸部素材API响应:', res);
          console.log('响应状态码:', res.statusCode);
          console.log('响应数据:', res.data);
          resolve(res.data);
        },
        fail: (error) => {
          console.error('?脸部素材API网络失败:', error);
          reject(new Error('网络请求失败: ' + error.errMsg));
        }
      });
    });
  },

  // 从API加载背景素材
  async loadBackgroundMaterials() {
    if (this.data.backgroundListLoading || this.data.backgroundListLoaded) {
      console.log('背景素材已在加载中或已加载');
      return;
    }

    console.log('🖼️开始加载背景素材');

    this.setData({
      backgroundListLoading: true
    });

    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      console.log('⚠️ 未登录，跳过背景素材加载');
      this.setData({
        backgroundListLoading: false
      });
      return;
    }

    try {
      const result = await this.callBackgroundMaterialsAPI(token);

      if (result && result.code === 1 && result.data && result.data.rows) {
        // 转换API数据格式为小程序需要的格式
        const backgroundList = result.data.rows
          .filter(item => item.status === 1) // 只显示启用的素材
          .map(item => ({
            id: item.materialId,
            name: item.materialName,
            url: item.imageUrl,
            thumbnail: item.thumbnailUrl || item.imageUrl,
            tags: item.tags || [],
            sortOrder: item.sortOrder || 0
          }))
          .sort((a, b) => a.sortOrder - b.sortOrder); // 按排序顺序排列
        this.setData({
          backgroundList: backgroundList,
          backgroundListLoading: false,
          backgroundListLoaded: true,
          // 设置默认背景（如果还没有设置的话）
          currentBackground: this.data.currentBackground || (backgroundList.length > 0 ? backgroundList[0].url : '')
        });

        console.log('✅背景素材加载成功，数量', backgroundList.length);

        // 如果有背景素材，设置第一个为默认背景
        if (backgroundList.length > 0 && !this.data.currentBackground) {
          console.log('🖼️设置默认背景:', backgroundList[0].url);
        }
      } else {
        throw new Error(result && result.msg ? result.msg : '获取背景素材失败');
      }
    } catch (error) {
      console.error('?加载背景素材失败:', error);

      this.setData({
        backgroundListLoading: false
      });

      // 如果API失败，使用默认背景素材
      this.setDefaultBackgroundMaterials();
    }
  },

  // 设置默认背景素材（API失败时的备用方案）
  setDefaultBackgroundMaterials() {
    console.log('🔄 使用默认背景素材');

    const defaultBackgrounds = [
      { id: 1, name: '海滩', url: 'https://images.unsplash.com/photo-1507525428034-b723cf961d3e?w=800&h=600&fit=crop', thumbnail: 'https://images.unsplash.com/photo-1507525428034-b723cf961d3e?w=150&h=100&fit=crop' },
      { id: 2, name: '城市', url: 'https://images.unsplash.com/photo-1449824913935-59a10b8d2000?w=800&h=600&fit=crop', thumbnail: 'https://images.unsplash.com/photo-1449824913935-59a10b8d2000?w=150&h=100&fit=crop' },
      { id: 3, name: '森林', url: 'https://images.unsplash.com/photo-1441974231531-c6227db76b6e?w=800&h=600&fit=crop', thumbnail: 'https://images.unsplash.com/photo-1441974231531-c6227db76b6e?w=150&h=100&fit=crop' },
      { id: 4, name: '工作', url: 'https://images.unsplash.com/photo-1586023492125-27b2c045efd7?w=800&h=600&fit=crop', thumbnail: 'https://images.unsplash.com/photo-1586023492125-27b2c045efd7?w=150&h=100&fit=crop' }
    ];

    this.setData({
      backgroundList: defaultBackgrounds,
      backgroundListLoaded: true,
      // 设置默认背景（如果还没有设置的话）
      currentBackground: this.data.currentBackground || (defaultBackgrounds.length > 0 ? defaultBackgrounds[0].url : '')
    });

    console.log('🖼️使用默认背景素材，设置默认背景', defaultBackgrounds[0]?.url);
  },

  // 调用背景素材API
  callBackgroundMaterialsAPI(token) {
    const app = getApp();
    return new Promise((resolve, reject) => {
      console.log('🔄 调用背景素材API');
      console.log('API地址:', `${app.globalData.baseUrl}/materials/backgrounds`);

      wx.request({
        url: `${app.globalData.baseUrl}/materials/backgrounds`,
        method: 'GET',
        timeout: 30000,
        header: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`
        },
        data: {
          status: 1, // 只获取启用的素材
          pageSize: 50 // 获取足够多的素材
        },
        success: (res) => {
          console.log('📥 背景素材API响应:', res);
          console.log('响应状态码:', res.statusCode);
          console.log('响应数据:', res.data);
          resolve(res.data);
        },
        fail: (error) => {
          console.error('?背景素材API网络失败:', error);
          reject(new Error('网络请求失败: ' + error.errMsg));
        }
      });
    });
  },

  // 选择模特图片
  chooseModelImage() {
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        this.setData({
          modelImage: res.tempFilePaths[0]
        });
        wx.showToast({
          title: '模特图片已更',
          icon: 'success'
        });
      }
    });
  },

  // 拍照
  takePhoto() {
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['camera'],
      success: (res) => {
        wx.showToast({
          title: '照片已保',
          icon: 'success'
        });
      }
    });
  },

  // 刷新模特
  refreshModel() {
    this.setData({
      currentClothing: null
    });
    wx.showToast({
      title: '已重置模',
      icon: 'success'
    });
  },

  // 切换标签页
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab;
    console.log('切换到标签页:', tab);

    // 需要登录验证的标签页（已移除隐藏的favorite和wardrobe）
    const requireAuthTabs = ['products', 'background', 'faceSwap'];
    
    // 如果当前标签需要登录验证
    if (requireAuthTabs.includes(tab)) {
      const app = getApp();
      const auth = require('../../utils/auth.js');
      
      // 检查是否已登录
      if (!auth.isLoggedIn()) {
        console.log('用户未登录，跳转到登录页面');
        wx.showToast({
          title: '请先登录',
          icon: 'none',
          duration: 2000
        });
        
        // 延迟跳转到登录页面
        setTimeout(() => {
          wx.navigateTo({
            url: '/pages/login/login'
          });
        }, 1500);
        return;
      }
      
      // 检查token是否有效
      auth.checkTokenValid().then((isValid) => {
        if (!isValid) {
          console.log('Token无效，跳转到登录页面');
          wx.showToast({
            title: '登录已过期，请重新登录',
            icon: 'none',
            duration: 2000
          });
          
          setTimeout(() => {
            wx.navigateTo({
              url: '/pages/login/login'
            });
          }, 1500);
          return;
        }
        
        // 登录验证通过，执行标签切换
        this.executeTabSwitch(tab);
      }).catch((error) => {
        console.error('Token验证失败:', error);
        wx.showToast({
          title: '登录验证失败，请重新登录',
          icon: 'none',
          duration: 2000
        });
        
        setTimeout(() => {
          wx.navigateTo({
            url: '/pages/login/login'
          });
        }, 1500);
      });
    } else {
      // 不需要登录验证的标签页，直接切换
      this.executeTabSwitch(tab);
    }
  },

  // 执行标签页切换的实际逻辑
  executeTabSwitch(tab) {
    console.log('执行标签页切换:', tab);

    this.setData({
      activeTab: tab
    });

    // 如果切换到全部商品标签或换脸标签，且数据未加载，则加载数据
    if ((tab === 'products' || tab === 'faceSwap') && !this.data.allProductsLoaded && !this.data.allProductsLoading) {
      console.log('📦 懒加载全部商品数据');
      this.loadAllProducts();
    }

    // 如果切换到衣橱标签，组织衣柜商品
    if (tab === 'wardrobe') {
      console.log('👗 切换到衣橱，组织商品分区');
      this.organizeWardrobeSectionProducts();
    }
  },

  // 跳转到衣橱页面
  navigateToWardrobe() {
    console.log('🚪 跳转到衣橱页面');
    wx.navigateTo({
      url: '/pages/wardrobe/wardrobe'
    });
  },

  // 恢复初始状态
  resetModel() {
    wx.showModal({
      title: '确认重置',
      content: '确定要恢复模特的初始状态吗',
      success: (res) => {
        if (res.confirm) {
          console.log('🔄 重置模特到初始状态');

          this.setData({
            modelImage: this.data.initialModelImage,
            currentClothing: null,
            currentBackground: '', // 清除当前背景
            selectedBackground: null, // 清除选中的背景
            customBackgroundImage: null, // 清除自定义背景
            customBackgroundThumbnail: null, // 清除缩略图
            // 重置换脸状态
            selectedFace: this.data.faceList.length > 0 ? this.data.faceList[0].id : null, // 默认选中第一张脸部素材
            customFaceImage: null, // 清除自定义人脸
            customFaceThumbnail: null, // 清除人脸缩略图
            customFaceMaterialId: null, // 清除自定义素材ID
            fusionDegree: 80, // 重置融合程度
            // 重置AI状态
            aiProcessing: false,
            aiLoading: false,
            aiProgress: 0,
            aiOperationType: 'tryon'
          });

          wx.showToast({
            title: '已重置',
            icon: 'success'
          });

          console.log('✅ 模特重置完成');
        }
      }
    });
  },

  // 分享给微信好友
  shareToFriend() {
    console.log('📤 开始分享给微信好友');

    // 先检查是否有模特图片
    if (!this.data.modelImage) {
      wx.showToast({
        title: '请先上传模特图片',
        icon: 'none'
      });
      return;
    }

    // 显示分享选项
    wx.showActionSheet({
      itemList: ['分享给微信好友', '保存到相册'],
      success: (res) => {
        if (res.tapIndex === 0) {
          // 分享给微信好友
          this.shareToWechatFriend();
        } else if (res.tapIndex === 1) {
          // 保存到相册
          this.saveToAlbum();
        }
      },
      fail: (res) => {
        console.log('用户取消分享');
      }
    });
  },

  // 分享给微信好友的具体实现
  shareToWechatFriend() {
    console.log('📤 分享给微信好友');

    // 使用微信小程序的分享功能
    wx.showShareMenu({
      withShareTicket: true,
      menus: ['shareAppMessage', 'shareTimeline']
    });

    // 触发分享
    wx.showToast({
      title: '请点击右上角分享',
      icon: 'none',
      duration: 2000
    });
  },

  // 保存到相册
  saveToAlbum() {
    console.log('💾 保存到相册');

    if (!this.data.modelImage) {
      wx.showToast({
        title: '没有可保存的图片',
        icon: 'none'
      });
      return;
    }

    // 请求保存图片到相册的权限
    wx.authorize({
      scope: 'scope.writePhotosAlbum',
      success: () => {
        this.doSaveToAlbum();
      },
      fail: () => {
        // 权限被拒绝，引导用户手动开启
        wx.showModal({
          title: '需要相册权限',
          content: '需要获取您的相册权限来保存图片',
          showCancel: true,
          confirmText: '去设置',
          success: (res) => {
            if (res.confirm) {
              wx.openSetting({
                success: (settingRes) => {
                  if (settingRes.authSetting['scope.writePhotosAlbum']) {
                    this.doSaveToAlbum();
                  }
                }
              });
            }
          }
        });
      }
    });
  },

  // 执行保存到相册
  doSaveToAlbum() {
    wx.showLoading({
      title: '保存中...'
    });

    // 如果是网络图片，先下载
    if (this.data.modelImage.startsWith('http')) {
      wx.downloadFile({
        url: this.data.modelImage,
        success: (res) => {
          if (res.statusCode === 200) {
            this.saveImageToAlbum(res.tempFilePath);
          } else {
            wx.hideLoading();
            wx.showToast({
              title: '下载图片失败',
              icon: 'error'
            });
          }
        },
        fail: () => {
          wx.hideLoading();
          wx.showToast({
            title: '下载图片失败',
            icon: 'error'
          });
        }
      });
    } else {
      // 本地图片直接保存
      this.saveImageToAlbum(this.data.modelImage);
    }
  },

  // 保存图片到相册
  saveImageToAlbum(imagePath) {
    wx.saveImageToPhotosAlbum({
      filePath: imagePath,
      success: () => {
        wx.hideLoading();
        wx.showToast({
          title: '保存成功',
          icon: 'success'
        });
        console.log('✅ 图片已保存到相册');
      },
      fail: (err) => {
        wx.hideLoading();
        console.error('❌ 保存图片失败:', err);
        wx.showToast({
          title: '保存失败',
          icon: 'error'
        });
      }
    });
  },

  // 生日输入（保留兼容性）
  onBirthdayInput(e) {
    this.setData({
      birthday: e.detail.value
    });
  },

  // 生日选择器变化
  onBirthdayChange(e) {
    const selectedDate = e.detail.value;
    console.log('📅 用户选择生日:', selectedDate);

    this.setData({
      birthday: selectedDate
    });

    // 验证选择的日期
    if (this.validateBirthday(selectedDate)) {
      console.log('✅生日格式验证通过');
    } else {
      console.warn('⚠️ 生日格式验证失败');
      wx.showToast({
        title: '请选择有效的日',
        icon: 'none'
      });
    }
  },

  // 设置生日并获取运势
  setupBirthdayAndGetFortune() {
    if (!this.data.birthday) {
      wx.showToast({
        title: '请输入生',
        icon: 'none'
      });
      return;
    }

    // 验证生日格式
    if (!this.validateBirthday(this.data.birthday)) {
      wx.showToast({
        title: '请输入正确的生日格式',
        icon: 'none'
      });
      return;
    }

    this.setData({ isSettingBirthday: true });

    // 先保存生日到用户信息
    this.updateUserBirthday(this.data.birthday);
  },

  // 获取运势（用户已设置生日）
  getFortune() {
    this.setData({ isGettingFortune: true });
    this.getFortuneRecommendation();
  },

  // 修改生日
  changeBirthday() {
    this.setData({
      userBirthdaySet: false,
      birthday: '',
      fortuneResult: '',
      recommendedProducts: [],
      constellation: ''
    });
  },

  // 查看运势 - 兼容旧方法
  checkFortune() {
    if (this.data.userBirthdaySet) {
      this.getFortune();
    } else {
      this.setupBirthdayAndGetFortune();
    }
  },

  // 验证生日格式
  validateBirthday(birthday) {
    const regex = /^\d{4}-\d{2}-\d{2}$/;
    if (!regex.test(birthday)) {
      return false;
    }

    const date = new Date(birthday);
    return date instanceof Date && !isNaN(date);
  },

  // 更新用户生日到后端
  updateUserBirthday(birthday) {
    const app = getApp();
    const token = app.globalData.token;

    console.log('🔄 开始更新用户生日');
    console.log('生日:', birthday);
    console.log('Token:', token ? token.substring(0, 20) + '...' : '无');
    console.log('API地址:', `${app.globalData.baseUrl}/users/profile`);

    if (!token) {
      console.error('?Token为空，无法更新生');
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      this.setData({ isSettingBirthday: false });
      return;
    }

    const requestData = {
      birthday: birthday
    };

    console.log('📤 发送请求数据', requestData);

    wx.request({
      url: `${app.globalData.baseUrl}/users/profile`,
      method: 'PUT',
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      },
      data: requestData,
      success: (res) => {
        console.log('📥 更新生日API响应:', res);
        console.log('响应状态码:', res.statusCode);
        console.log('响应数据:', res.data);
        this.handleBirthdayUpdateResponse(res, birthday);
      },
      fail: (error) => {
        console.error('?更新生日API失败:', error);
        this.setData({ isSettingBirthday: false });
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      }
    });
  },

  // 处理生日更新响应
  handleBirthdayUpdateResponse(res, birthday) {
    this.setData({ isSettingBirthday: false });

    if (res.statusCode === 200 && res.data.code === 1) {
      // 更新成功
      console.log('✅生日更新成功');

      // 更新本地用户信息
      const app = getApp();
      if (app.globalData.userInfo) {
        app.globalData.userInfo.birthday = birthday;
        wx.setStorageSync('userInfo', app.globalData.userInfo);
      }

      // 更新页面状态
      this.setData({
        userBirthdaySet: true,
        birthday: birthday
      });

      wx.showToast({
        title: '生日设置成功',
        icon: 'success'
      });

      // 自动获取运势
      setTimeout(() => {
        this.getFortuneRecommendation();
      }, 1000);

    } else {
      // 更新失败
      const errorMsg = res.data.msg || '生日设置失败';
      console.error('?生日更新失败:', res.data);

      wx.showModal({
        title: '设置失败',
        content: errorMsg,
        showCancel: false
      });
    }
  },

  // 获取运势推荐
  getFortuneRecommendation() {
    const app = getApp();
    const token = app.globalData.token;
    const storageToken = wx.getStorageSync('token');
    const userInfo = wx.getStorageSync('userInfo');

    console.log('🔮 开始获取运势推荐');
    console.log('=== Token调试信息 ===');
    console.log('GlobalData Token:', token ? token.substring(0, 20) + '...' : '无');
    console.log('Storage Token:', storageToken ? storageToken.substring(0, 20) + '...' : '无');
    console.log('用户信息:', userInfo ? `用户ID: ${userInfo.userId}, 昵称: ${userInfo.nickname}` : '无');
    console.log('登录状态:', app.globalData.isLogin);
    console.log('API地址:', `${app.globalData.baseUrl}/recommendations/fortune`);
    console.log('==================');

    // 优先使用存储中的token，如果globalData中的token为空
    let actualToken = token || storageToken;
    
    if (!actualToken) {
      console.error('❌ Token为空，无法获取运势');
      console.log('建议用户重新登录');
      
      wx.showModal({
        title: '登录已过期',
        content: '请重新登录后再查看运势',
        confirmText: '去登录',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            wx.reLaunch({
              url: '/pages/login/login'
            });
          }
        }
      });
      
      this.setData({ isGettingFortune: false });
      return;
    }

    // 如果globalData中的token为空，但storage中有token，则同步到globalData
    if (!token && storageToken) {
      console.log('🔄 同步Storage中的Token到GlobalData');
      app.globalData.token = storageToken;
      app.globalData.isLogin = true;
      if (userInfo) {
        app.globalData.userInfo = userInfo;
      }
      actualToken = storageToken;
    }

    // 显示加载状态
    wx.showLoading({
      title: '正在获取运势...'
    });

    // 使用修改后的运势接口（传递birthday参数）
    wx.request({
      url: `${app.globalData.baseUrl}/recommendations/fortune`,
      method: 'GET',
      data: {
        birthday: this.data.birthday
      },
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${actualToken}`
      },
      timeout: 10000, // 10秒超时
      success: (res) => {
        wx.hideLoading();
        console.log('✅ 运势推荐API响应成功', res);
        console.log('📊 响应状态码:', res.statusCode);
        console.log('📄 响应数据:', res.data);
        
        // 按照成功API的模式处理响应
        this.handleFortuneResponse(res);
      },
      fail: (error) => {
        wx.hideLoading();
        console.error('❌ 运势推荐API请求失败', error);
        console.error('🔍 错误详情:', JSON.stringify(error));
        
        this.setData({ isGettingFortune: false });
        
        // 根据错误类型显示不同提示（模仿登录API的错误处理）
        if (error.errMsg && error.errMsg.includes('timeout')) {
          this.showFortuneError('请求超时，请检查网络连接');
        } else if (error.errMsg && error.errMsg.includes('fail')) {
          this.showFortuneError(`网络连接失败：${error.errMsg}`);
        } else {
          this.showFortuneError(`运势获取失败：${error.errMsg || '未知错误'}`);
        }
      }
    });
  },

  // 处理运势推荐响应（按照成功API的标准模式）
  handleFortuneResponse(res) {
    // 重置加载状态
    this.setData({ isGettingFortune: false });

    // 检查HTTP状态码（和登录API一致的检查方式）
    if (res.statusCode !== 200) {
      console.error('❌ HTTP请求失败', res);
      this.showFortuneError(`服务器错误 (${res.statusCode})，请稍后重试`);
      return;
    }

    // 检查业务状态码（和登录API一致）
    if (res.data.code === 1) {
      const data = res.data.data;

      console.log('🎉 运势推荐获取成功！详情:');
      console.log('星座:', data.constellation);
      console.log('运势关键词:', data.fortuneKeywords);
      console.log('推荐商品数量:', data.recommendedProducts ? data.recommendedProducts.length : 0);
      console.log('完整数据:', data);

      // 验证返回数据的完整性
      if (!data.constellation || !data.recommendedProducts) {
        console.error('运势响应数据不完整', res.data);
        this.showFortuneError('运势数据异常，请重试');
        return;
      }

      // 构建运势文本
      const fortuneText = this.buildFortuneText(data);

      // 更新页面数据（先不设置推荐商品）
      this.setData({
        fortuneResult: fortuneText,
        constellation: data.constellation,
        fortuneKeywords: data.fortuneKeywords || [],
        colorKeywords: data.colorKeywords || [],
        styleKeywords: data.styleKeywords || [],
        recommendationId: data.recommendationId
      });

      // 🎯 前端直接获取外部商品数据
      this.getExternalProducts();

      // 显示成功提示
      wx.showToast({
        title: `${data.constellation}运势已更新`,
        icon: 'success',
        duration: 2000
      });

      console.log('✅ 运势信息更新完成');

    } else {
      // 处理业务错误（模仿登录API的错误处理方式）
      const errorCode = res.data.code;
      const errorMsg = res.data.msg || '获取运势失败';

      console.error('❌ 运势推荐业务错误', res.data);
      console.error('🔍 错误详情 - 错误码:', errorCode, '错误信息:', errorMsg);

      // 根据错误码显示不同提示（和登录API类似的switch结构）
      switch (errorCode) {
        case 60001:
          this.showFortuneError('请先设置生日信息');
          // 如果生日未设置，重置状态
          this.setData({
            userBirthdaySet: false,
            birthday: ''
          });
          break;
          
        case 60003:
          this.showFortuneError('星座配置错误，请联系管理员');
          break;
          
        case 60005:
        // 商品匹配失败，但运势查看应该正常工作
        console.warn('商品匹配失败，尝试获取基础运势信息');
        console.log('检查是否有运势数据:', res.data.data ? '有' : '无');
        
        // 如果返回了运势数据，仍然显示运势信息
        if (res.data.data && res.data.data.constellation) {
          const data = res.data.data;
          
          // 构建运势文本
          const fortuneText = this.buildFortuneText(data);
          
          // 更新页面数据（不包含推荐商品）
          this.setData({
            fortuneResult: fortuneText,
            recommendedProducts: [], // 商品匹配失败，清空推荐商品
            constellation: data.constellation,
            fortuneKeywords: data.fortuneKeywords || [],
            colorKeywords: data.colorKeywords || [],
            styleKeywords: data.styleKeywords || [],
            recommendationId: data.recommendationId
          });
          
          // 显示运势成功，但提示商品匹配失败
          wx.showToast({
            title: `${data.constellation}运势已更新`,
            icon: 'success'
          });
          
          // 额外提示商品匹配失败（不影响运势查看）
          setTimeout(() => {
            wx.showToast({
              title: '商品推荐暂时不可用',
              icon: 'none',
              duration: 2000
            });
          }, 1500);
          
        } else {
          // 没有运势数据，尝试调用基础运势接口
          console.log('🔄 商品匹配失败且无运势数据，尝试获取基础星座运势');
          this.getBasicFortune();
        }
        break;
          
        default:
          this.showFortuneError(errorMsg);
          break;
      }
    }
  },

  // 构建运势文本
  buildFortuneText(data) {
    let fortuneText = `🌟 ${data.constellation} (${data.fortuneDate})\n\n`;

    if (data.fortuneKeywords && data.fortuneKeywords.length > 0) {
      fortuneText += `💫 今日运势关键词：${data.fortuneKeywords.join(', ')}\n`;
    }

    if (data.colorKeywords && data.colorKeywords.length > 0) {
      fortuneText += `🎨 幸运色彩：${data.colorKeywords.join(', ')}\n`;
    }

    if (data.styleKeywords && data.styleKeywords.length > 0) {
      fortuneText += `👗 推荐风格：${data.styleKeywords.join(', ')}\n`;
    }

    fortuneText += '\n?根据您的星座运势，为您推荐以下商品！';

    return fortuneText;
  },

  // 🎯 前端计算星座（根据用户生日）
  calculateConstellationFromBirthday() {
    const birthday = this.data.birthday;
    if (!birthday) {
      console.log('⚠️ 用户未设置生日，使用默认星座');
      return '摩羯座'; // 默认返回摩羯座
    }

    try {
      const date = new Date(birthday);
      const month = date.getMonth() + 1; // getMonth()返回0-11，需要+1
      const day = date.getDate();

      console.log(`🎯 计算星座：生日 ${month}月${day}日`);

      if ((month == 3 && day >= 21) || (month == 4 && day <= 19)) {
        return '白羊座';
      } else if ((month == 4 && day >= 20) || (month == 5 && day <= 20)) {
        return '金牛座';
      } else if ((month == 5 && day >= 21) || (month == 6 && day <= 21)) {
        return '双子座';
      } else if ((month == 6 && day >= 22) || (month == 7 && day <= 22)) {
        return '巨蟹座';
      } else if ((month == 7 && day >= 23) || (month == 8 && day <= 22)) {
        return '狮子座';
      } else if ((month == 8 && day >= 23) || (month == 9 && day <= 22)) {
        return '处女座';
      } else if ((month == 9 && day >= 23) || (month == 10 && day <= 23)) {
        return '天秤座';
      } else if ((month == 10 && day >= 24) || (month == 11 && day <= 22)) {
        return '天蝎座';
      } else if ((month == 11 && day >= 23) || (month == 12 && day <= 21)) {
        return '射手座';
      } else if ((month == 12 && day >= 22) || (month == 1 && day <= 19)) {
        return '摩羯座';
      } else if ((month == 1 && day >= 20) || (month == 2 && day <= 18)) {
        return '水瓶座';
      } else {
        return '双鱼座';
      }
    } catch (error) {
      console.error('计算星座失败:', error);
      return '摩羯座'; // 出错时返回默认星座
    }
  },

  // 🎯 获取星座对应的运势信息
  getConstellationInfo(constellation) {
    const constellationData = {
      '白羊座': {
        fortuneKeywords: ['热情', '勇敢', '积极', '领导'],
        colorKeywords: ['红色', '橙色', '金色'],
        styleKeywords: ['运动风', '活力风', '简约风']
      },
      '金牛座': {
        fortuneKeywords: ['稳重', '务实', '温和', '坚持'],
        colorKeywords: ['绿色', '棕色', '米色'],
        styleKeywords: ['经典风', '舒适风', '自然风']
      },
      '双子座': {
        fortuneKeywords: ['机智', '灵活', '好奇', '沟通'],
        colorKeywords: ['黄色', '银色', '浅蓝'],
        styleKeywords: ['时尚风', '多变风', '青春风']
      },
      '巨蟹座': {
        fortuneKeywords: ['温柔', '体贴', '家庭', '感性'],
        colorKeywords: ['白色', '银色', '浅粉'],
        styleKeywords: ['温馨风', '柔美风', '居家风']
      },
      '狮子座': {
        fortuneKeywords: ['自信', '大方', '热情', '王者'],
        colorKeywords: ['金色', '橙色', '红色'],
        styleKeywords: ['华丽风', '大气风', '贵族风']
      },
      '处女座': {
        fortuneKeywords: ['细致', '完美', '理性', '服务'],
        colorKeywords: ['米色', '灰色', '浅绿'],
        styleKeywords: ['简约风', '精致风', '知性风']
      },
      '天秤座': {
        fortuneKeywords: ['和谐', '优雅', '平衡', '美感'],
        colorKeywords: ['粉色', '浅蓝', '薰衣草'],
        styleKeywords: ['优雅风', '和谐风', '艺术风']
      },
      '天蝎座': {
        fortuneKeywords: ['神秘', '深刻', '专注', '转化'],
        colorKeywords: ['深红', '黑色', '紫色'],
        styleKeywords: ['神秘风', '性感风', '深沉风']
      },
      '射手座': {
        fortuneKeywords: ['自由', '乐观', '冒险', '哲学'],
        colorKeywords: ['紫色', '蓝色', '绿色'],
        styleKeywords: ['自由风', '休闲风', '冒险风']
      },
      '摩羯座': {
        fortuneKeywords: ['稳重', '务实', '坚韧', '成功'],
        colorKeywords: ['深蓝色', '黑色', '棕色'],
        styleKeywords: ['商务风', '经典风', '简约风']
      },
      '水瓶座': {
        fortuneKeywords: ['创新', '独立', '理性', '前卫'],
        colorKeywords: ['蓝色', '银色', '白色'],
        styleKeywords: ['前卫风', '个性风', '科技风']
      },
      '双鱼座': {
        fortuneKeywords: ['浪漫', '梦幻', '温柔', '艺术'],
        colorKeywords: ['紫色', '粉色', '蓝色'],
        styleKeywords: ['浪漫风', '梦幻风', '艺术风']
      }
    };

    return constellationData[constellation] || constellationData['摩羯座'];
  },

  // 🎯 前端直接获取外部商品数据
  async getExternalProducts() {
    try {
      console.log('🔄 前端开始获取外部商品数据...');

      const response = await new Promise((resolve, reject) => {
        wx.request({
          url: 'https://xry.zysemtime.com/api/product/spu/merchant/1',
          method: 'GET',
          timeout: 10000,
          success: resolve,
          fail: reject
        });
      });

      if (response.statusCode === 200 && response.data.status === 200) {
        const products = response.data.data.list;
        console.log('✅ 外部API返回商品数量:', products.length);

        // 随机选择4个商品
        const shuffled = products.sort(() => 0.5 - Math.random());
        const selectedProducts = shuffled.slice(0, 4);

        // 转换数据格式
        const recommendedProducts = selectedProducts.map(product => ({
          productId: String(product.product_id), // 确保是字符串
          productName: product.store_name,
          productPrice: parseFloat(product.price),
          originalPrice: product.ot_price || parseFloat(product.price),
          productImage: product.image,
          clothesType: "Upper-body",
          matchReason: "根据您的星座运势精心推荐",
          matchScore: 85 + Math.floor(Math.random() * 15), // 85-99分
          productUrl: null,
          tags: ["推荐", "今日精选"],
          favorited: false,
          isFavorite: false,
          // 添加额外的ID字段以确保兼容性
          id: String(product.product_id),
          product_id: String(product.product_id)
        }));

        console.log('✅ 转换后的推荐商品:', recommendedProducts);

        // 更新页面数据
        this.setData({
          recommendedProducts: recommendedProducts
        });

        // 检查推荐商品的收藏状态
        this.checkRecommendedProductsFavoriteStatus(recommendedProducts);

      } else {
        throw new Error('外部API返回异常');
      }
    } catch (error) {
      console.error('❌ 获取外部商品失败:', error);

      // 失败时使用备用商品数据
      const fallbackProducts = [
        {
          productId: "fallback_1",
          productName: "时尚休闲T恤",
          productPrice: 99.00,
          originalPrice: 149.00,
          productImage: "https://img.alicdn.com/imgextra/i1/2208857268292/O1CN01YQX8ZL1Uw8QXxQxQx_!!2208857268292.jpg",
          clothesType: "Upper-body",
          matchReason: "根据您的星座运势精心推荐",
          matchScore: 88,
          productUrl: null,
          tags: ["推荐", "今日精选"],
          favorited: false,
          isFavorite: false
        }
      ];

      this.setData({
        recommendedProducts: fallbackProducts
      });
    }
  },

  // 获取基础运势信息
  getBasicFortune() {
    console.log('🔄 尝试获取基础星座运势');

    // 这里可以调用一个基础的星座运势API
    // 或者显示默认的运势信息
    wx.showToast({
      title: '运势功能暂时不可用',
      icon: 'none',
      duration: 2000
    });

    // 设置默认的运势显示
    this.setData({
      fortuneText: '🌟 今日运势\n\n💫 保持积极的心态，好运自然来！\n🎨 建议选择明亮的颜色\n👗 推荐简约舒适的风格',
      recommendedProducts: [],
      isLoadingFortune: false
    });
  },

  // 显示运势错误
  showFortuneError(message) {
    wx.showModal({
      title: '运势获取失败',
      content: message,
      showCancel: false,
      confirmText: '知道'
    });
  },

  // 调试工具：检查Token状态
  checkTokenStatus() {
    const app = getApp();
    const storageToken = wx.getStorageSync('token');
    const storageUserInfo = wx.getStorageSync('userInfo');
    
    const debugInfo = {
      'GlobalData登录状态': app.globalData.isLogin,
      'GlobalData Token': app.globalData.token ? '存在' : '不存在',
      'Storage Token': storageToken ? '存在' : '不存在',
      'Storage UserInfo': storageUserInfo ? '存在' : '不存在',
      'API地址': app.globalData.baseUrl
    };
    
    console.log('🔍 Token状态检查结果:', debugInfo);
    
    let statusText = '';
    for (const [key, value] of Object.entries(debugInfo)) {
      statusText += `${key}: ${value}\n`;
    }
    
    wx.showModal({
      title: 'Token状态检查',
      content: statusText,
      showCancel: false,
      confirmText: '确定'
    });
    
    return debugInfo;
  },

  // 调试工具：测试运势API连接
  testFortuneAPI() {
    console.log('🧪 开始测试运势API连接...');
    
    // 直接调用运势推荐方法进行测试
    this.setData({ isGettingFortune: true });
    this.getFortuneRecommendation();
  },

  // 记录推荐商品点击
  recordRecommendationClick(e) {
    const productId = e.currentTarget.dataset.productId;
    if (!productId) return;
    const app = getApp();
    const token = app.globalData.token;
    const recommendationId = this.data.recommendationId;

    if (!token || !recommendationId) {
      return;
    }

    wx.request({
      url: `${app.globalData.baseUrl}/recommendations/${recommendationId}/click`,
      method: 'POST',
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      },
      data: {
        productId: productId,
        actionType: 'click'
      },
      success: (res) => {
        console.log('推荐点击记录成功:', res);
      },
      fail: (error) => {
        console.error('推荐点击记录失败:', error);
      }
    });
  },

  // 记录推荐商品试穿
  recordRecommendationTryOn(productId) {
    const app = getApp();
    const token = app.globalData.token;
    const recommendationId = this.data.recommendationId;

    if (!token || !recommendationId) {
      return;
    }

    wx.request({
      url: `${app.globalData.baseUrl}/recommendations/${recommendationId}/tryOn`,
      method: 'POST',
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      },
      data: {
        productId: productId,
        actionType: 'tryOn'
      },
      success: (res) => {
        console.log('推荐试穿记录成功:', res);
      },
      fail: (error) => {
        console.error('推荐试穿记录失败:', error);
      }
    });
  },

  // 选择商品（显示商品图片到模特区域）
  selectProduct(e) {
    console.log('👗 selectProduct 被调用 - 显示商品图片');
    const item = e.currentTarget.dataset.item;
    
    if (!item) {
      console.error('商品数据为空');
      return;
    }
    
    // 获取商品图片
    const productImage = item.image || item.productImage;
    if (!productImage) {
      wx.showToast({
        title: '商品图片不存在',
        icon: 'none'
      });
      return;
    }
    
    // 更新模特区域显示商品图片
    this.setData({
      modelImage: productImage,
      selectedProduct: item
    });
    
    // 滚动到底部
    this.scrollToBottom();
    
    console.log('商品图片已显示到模特区域:', productImage);
  },

  // 滚动到页面底部
  scrollToBottom() {
    wx.pageScrollTo({
      scrollTop: 99999,
      duration: 500
    });
  },

  // 试穿服装（现在使用换脸功能）
  async tryOnClothing(e) {
    console.log('👗 tryOnClothing 被调用 - 使用换脸功能');
    
    // 优先使用selectedProduct，如果没有则从事件中获取
    let item = this.data.selectedProduct;
    if (!item && e && e.currentTarget && e.currentTarget.dataset) {
      item = e.currentTarget.dataset.item;
    }
    
    console.log('商品数据:', item);

    // 添加调试信息
    if (!item) {
      console.error('商品数据为空，请先选择商品');
      wx.showToast({
        title: '请先选择商品',
        icon: 'none'
      });
      return;
    }

    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      console.log('❌用户未登录，需要登录后才能试穿');
      wx.showModal({
        title: '需要登录',
        content: '试穿功能需要登录后使用，是否前往登录？',
        confirmText: '去登录',
        cancelText: '稍后再说',
        success: (res) => {
          if (res.confirm) {
            // 使用reLaunch确保登录后能正确返回
            wx.reLaunch({
              url: '/pages/login/login'
            });
          }
        }
      });
      return;
    }

    // 检查算力余额
    if (this.data.userEnergy < 1) {
      wx.showModal({
        title: '算力不足',
        content: '您的算力余额不足，请联系管理员充值',
        showCancel: false
      });
      return;
    }

    // 检查是否选择了脸部素材或上传了照片
    if (!this.data.selectedFace && !this.data.customFaceImage) {
      wx.showToast({
        title: '请先选择形象或上传照片',
        icon: 'none'
      });
      return;
    }

    // 获取商品ID，支持多种字段名
    const productId = item.productId || item.product_id || item.id;

    console.log('👤 开始换脸试穿', {
      productId: productId,
      productName: item.productName || item.name,
      selectedFace: this.data.selectedFace,
      customFaceImage: this.data.customFaceImage,
      modelImage: this.data.modelImage,
      fusionDegree: this.data.fusionDegree
    });

    // 设置试穿加载状态
    this.updateProductLoadingState(productId, 'tryOnLoading', true);

    // 如果是推荐商品，记录试穿行为
    if (this.data.recommendationId && productId) {
      this.recordRecommendationTryOn(productId);
    }

    // 显示AI处理动画
    this.setData({
      aiProcessing: true,
      aiProgress: 0,
      aiOperationType: 'face'
    });

    // 模拟进度条动画 - 换脸处理
    const progressTimer = setInterval(() => {
      const currentProgress = this.data.aiProgress;
      if (currentProgress < 85) {
        // 前期进度较快
        if (currentProgress < 30) {
          this.setData({
            aiProgress: currentProgress + 8
          });
        } else if (currentProgress < 60) {
          // 中期进度较慢
          this.setData({
            aiProgress: currentProgress + 3
          });
        } else {
          // 后期进度很慢
          this.setData({
            aiProgress: currentProgress + 1
          });
        }
      }
    }, 800);

    try {
      // 获取当前模特图片（商品图片）
      const sourceImageUrl = item.productImage || item.image; // 使用商品主图作为原始图片
      let faceImageUrl = null;
      let materialId = null;

      console.log('🖼️ 商品图片（作为原始图片）:', sourceImageUrl);

      // 确定使用的人脸素材
      if (this.data.customFaceImage) {
        // 使用自定义上传的人脸
        faceImageUrl = this.data.customFaceImage;
        materialId = this.data.customFaceMaterialId || this.data.customFaceImage;
        
        console.log('👤 使用自定义人脸:', {
          faceImageUrl: faceImageUrl,
          materialId: materialId,
          note: '使用自定义上传的人脸图片URL作为materialId'
        });
      } else if (this.data.selectedFace) {
        // 使用预设脸部素材
        const selectedFaceMaterial = this.data.faceList.find(face => face.id === this.data.selectedFace);
        if (!selectedFaceMaterial) {
          throw new Error('未找到选择的脸部素材');
        }
        faceImageUrl = selectedFaceMaterial.imageUrl;
        materialId = selectedFaceMaterial.id;

        console.log('👤 使用预设脸部素材:', {
          faceImageUrl: faceImageUrl,
          materialId: materialId,
          material: selectedFaceMaterial
        });
      } else {
        throw new Error('请选择脸部素材或上传自定义人脸');
      }

      // 调用换脸API
      const result = await this.callFaceFusionAPI(
        sourceImageUrl,
        faceImageUrl, 
        materialId,
        this.data.fusionDegree,
        token
      );

      // 清除进度条定时器
      clearInterval(progressTimer);

      console.log('🔍 换脸API返回结果:', result);
      console.log('🔍 详细数据结构:', JSON.stringify(result, null, 2));

      // 检查API是否成功
      if (result && result.code === 1) {
        console.log('✅ 换脸API调用成功，检查返回数据...');

        // 检查是否有直接的结果图片
        if (result.data && result.data.resultImageUrl) {
          console.log('✅ 获得直接结果图片:', result.data.resultImageUrl);
          
          // 完成进度
          this.setData({
            aiProgress: 100
          });

          // 延迟一下显示完成效果
          setTimeout(() => {
            // 换脸成功，更新模特图片
            this.setData({
              modelImage: result.data.resultImageUrl,
              aiProcessing: false,
              aiProgress: 0,
              aiOperationType: 'face'
            });

            // 更新试穿状态
            this.updateProductLoadingState(productId, 'tryOnLoading', false);

            // 换脸成功后，重新获取用户信息以同步算力
            this.refreshUserInfo();

            wx.showToast({
              title: '换脸完成',
              icon: 'success'
            });

            console.log('✅换脸成功，新图片:', result.data.resultImageUrl);
          }, 500);
        }
        // 检查是否需要通过operationId查询结果
        else if (result.needQueryResult && result.data && result.data.operationId) {
          console.log('🔄 需要通过operationId查询结果:', result.data.operationId);
          console.log('🔄 当前processingTime:', result.data.processingTime);

          // 继续显示进度条，开始查询结果
          this.setData({
            aiProgress: 90
          });

          try {
            // 查询操作结果
            const operationResult = await this.queryOperationResult(result.data.operationId, token);
            console.log('🔍 查询操作结果:', operationResult);

            // 检查查询结果中是否有图片URL
            let finalImageUrl = null;
            if (operationResult && operationResult.data) {
              finalImageUrl = operationResult.data.resultImageUrl || 
                            operationResult.data.imageUrl || 
                            operationResult.data.url;
            }

            if (finalImageUrl) {
              console.log('✅ 通过operationId查询到结果图片:', finalImageUrl);

              // 完成进度
              this.setData({
                aiProgress: 100
              });

              // 延迟一下显示完成效果
              setTimeout(() => {
                // 换脸成功，更新模特图片
                this.setData({
                  modelImage: finalImageUrl,
                  aiProcessing: false,
                  aiProgress: 0,
                  aiOperationType: 'face'
                });

                // 更新试穿状态
                this.updateProductLoadingState(productId, 'tryOnLoading', false);

                // 换脸成功后，重新获取用户信息以同步算力
                this.refreshUserInfo();

                wx.showToast({
                  title: '换脸完成',
                  icon: 'success'
                });

                console.log('✅通过operationId查询换脸成功，新图片:', finalImageUrl);
              }, 500);
            } else {
              console.error('?查询操作结果中未找到图片URL');
              console.error('?完整查询结果:', operationResult);
              throw new Error('查询操作结果失败：未找到结果图片');
            }
          } catch (queryError) {
            console.error('?查询操作结果失败:', queryError);
            throw new Error('换脸处理失败：' + queryError.message);
          }
        } else {
          // 既没有直接结果，也没有operationId
          const errorMsg = result && result.msg ? result.msg : '换脸失败，请重试';
          console.error('?API返回错误:', errorMsg);
          throw new Error(errorMsg);
        }
      } else {
        // 处理API返回的错误
        const errorMsg = result && result.msg ? result.msg : '换脸失败，请重试';
        console.error('❌ 换脸API调用失败:', errorMsg);
        console.error('返回码:', result ? result.code : 'undefined');
        throw new Error(errorMsg);
      }
    } catch (error) {
      console.error('❌换脸失败:', error);
      console.error('错误类型:', typeof error);
      console.error('错误详情:', error.message || error);

      // 清除进度条定时器
      if (progressTimer) {
        clearInterval(progressTimer);
      }

      // 重置状态
      this.setData({
        aiProcessing: false,
        aiProgress: 0,
        aiOperationType: 'face'
      });
      this.updateProductLoadingState(productId, 'tryOnLoading', false);

      // 显示用户友好的错误信息
      let errorMessage = '换脸失败，请重试';
      if (error.message) {
        if (error.message.includes('网络')) {
          errorMessage = '网络连接失败，请检查网络';
        } else if (error.message.includes('登录')) {
          errorMessage = '登录已过期，请重新登录';
        } else if (error.message.includes('Token余额不足')) {
          errorMessage = '算力余额不足，请联系管理员充值';
        } else if (error.message.includes('未检测到人脸')) {
          errorMessage = '未检测到人脸，请使用清晰的人脸图片';
        } else if (error.message.includes('HTTP错误')) {
          errorMessage = '服务器连接失败，请稍后重试';
        } else {
          errorMessage = error.message;
        }
      }

      wx.showToast({
        title: errorMessage,
        icon: 'none',
        duration: 3000
      });
    }
  },

  // 滚动到顶部
  scrollToTop() {
    console.log('📱 滚动到顶部按钮被点击');
    wx.pageScrollTo({
      scrollTop: 0,
      duration: 500
    });
    
    // 添加触觉反馈
    wx.vibrateShort();
    
    // 显示提示
    wx.showToast({
      title: '已回到顶部',
      icon: 'success',
      duration: 1000
    });
  },

  // 调用AI换装API
  callTryOnAPI(modelImage, clothingImage, token, clothesType = 'Upper-body', productId = null) {
    const app = getApp();
    return new Promise((resolve, reject) => {
      console.log('🔄 调用AI换装API');
      console.log('模特图片:', modelImage);
      console.log('服装图片:', clothingImage);
      console.log('API地址:', `${app.globalData.baseUrl}/ai/change-clothes`);

      wx.request({
        url: `${app.globalData.baseUrl}/ai/change-clothes`,
        method: 'POST',
        timeout: 120000, // 设置超时时间2分钟
        header: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`
        },
        data: {
          modelImageUrl: modelImage,
          clothesImageUrl: clothingImage,  // 修正字段名
          clothesType: clothesType, // 使用传入的服装类型
          productId: productId ? String(productId) : null, // 添加商品ID用于统计
          logoAdd: 1 // 添加AI标识
        },
        success: (res) => {
          console.log('📥 AI换装API响应:', res);
          console.log('响应状态码:', res.statusCode);
          console.log('响应数据:', res.data);
          resolve(res.data);
        },
        fail: (error) => {
          console.error('?AI换装API网络失败:', error);
          console.error('错误详情:', error);

          // 根据错误类型提供更友好的提示
          let errorMessage = '网络请求失败';
          if (error.errMsg) {
            if (error.errMsg.includes('timeout')) {
              errorMessage = 'AI换装处理超时，请稍后重试';
            } else if (error.errMsg.includes('fail')) {
              errorMessage = '网络连接失败，请检查网';
            } else {
              errorMessage = error.errMsg;
            }
          }

          reject(new Error(errorMessage));
        }
      });
    });
  },



  // 购买商品
  buyProduct(e) {
    const item = e.currentTarget.dataset.item;
    wx.showModal({
      title: '购买确认',
      content: `确定要购买${item.name} 吗？`,
      success: (res) => {
        if (res.confirm) {
          wx.showToast({
            title: '购买成功',
            icon: 'success'
          });
        }
      }
    });
  },

  // 选择背景（简单版本，用于快速预览）
  changeBackground(e) {
    const url = e.currentTarget.dataset.url;
    const id = e.currentTarget.dataset.id;

    // 设置选中的背景
    this.setData({
      selectedBackground: id,
      customBackgroundImage: null, // 清除自定义背景
      customBackgroundThumbnail: null // 清除缩略图
    });

    console.log('选择背景:', { id, url });

    wx.showToast({
      title: '背景已选择',
      icon: 'success'
    });
  },

  // 点赞商品
  likeProduct(e) {
    const item = e.currentTarget.dataset.item;
    wx.showToast({
      title: '点赞成功',
      icon: 'success'
    });
  },

  // 从衣橱移除
  async removeFromWardrobe(e) {
    const item = e.currentTarget.dataset.item;
    const productName = item.productName || item.name;

    wx.showModal({
      title: '确认移除',
      content: `确定要从衣橱移除"${productName}"吗？`,
      success: async (res) => {
        if (res.confirm) {
          try {
            wx.showLoading({
              title: '移除中...',
              mask: true
            });

            const app = getApp();
            const token = app.globalData.token;

            if (!token) {
              wx.hideLoading();
              wx.showToast({
                title: '请先登录',
                icon: 'none'
              });
              return;
            }

            // 调用取消收藏API
            await this.removeFavoriteAPI(token, item.productId);

            // 从本地数据中移除
            const updatedItems = this.data.wardrobeItems.filter(wardrobeItem =>
              wardrobeItem.favoriteId !== item.favoriteId
            );

            this.setData({
              wardrobeItems: updatedItems,
              currentWardrobeItems: updatedItems,
              totalWardrobeCount: updatedItems.length
            });

            // 更新分类商品数量
            this.updateCategoryProductCount();

            wx.hideLoading();
            wx.showToast({
              title: '已移除',
              icon: 'success'
            });

            console.log('✅ 商品已从衣橱移除:', productName);

          } catch (error) {
            console.error('❌ 移除商品失败:', error);
            wx.hideLoading();
            wx.showToast({
              title: error.message || '移除失败',
              icon: 'none'
            });
          }
        }
      }
    });
  },

  // 选择衣橱分类
  selectWardrobeCategory(e) {
    const categoryId = e.currentTarget.dataset.categoryId;

    console.log('👔 选择衣橱分类:', categoryId);

    this.setData({
      selectedCategory: categoryId
    });

    // 根据分类筛选商品
    this.filterWardrobeItemsByCategory(categoryId);

    // 如果是特定分类且数据不完整，重新加载
    if (categoryId > 0 && this.data.wardrobeItems.length === 0) {
      this.loadWardrobeItems(categoryId, 1, this.data.wardrobePageSize);
    }
  },

  // 根据分类筛选衣橱商品
  filterWardrobeItemsByCategory(categoryId) {
    let filteredItems;

    if (categoryId === 0) {
      // 显示全部
      filteredItems = this.data.wardrobeItems;
    } else {
      // 按分类筛选
      filteredItems = this.data.wardrobeItems.filter(item =>
        item.categoryId === categoryId
      );
    }

    this.setData({
      currentWardrobeItems: filteredItems
    });

    console.log('✅ 衣橱商品筛选完成:', {
      categoryId: categoryId,
      totalItems: this.data.wardrobeItems.length,
      filteredItems: filteredItems.length
    });
  },

  // 加载更多衣橱商品
  loadMoreWardrobeItems() {
    if (this.data.wardrobeItemsLoading || !this.data.hasMoreWardrobeItems) {
      return;
    }

    const nextPage = this.data.wardrobePage + 1;
    const categoryId = this.data.selectedCategory > 0 ? this.data.selectedCategory : null;

    this.loadWardrobeItems(categoryId, nextPage, this.data.wardrobePageSize);
  },

  // 刷新衣橱数据
  refreshWardrobeData() {
    console.log('🔄 刷新衣橱数据');

    this.setData({
      wardrobeItemsLoaded: false,
      wardrobeCategoriesLoaded: false
    });

    // 重新加载数据
    this.loadWardrobeCategories();
    this.loadWardrobeItems();
  },

  // 显示商品移动模态框
  showMoveToCategory(e) {
    const item = e.currentTarget.dataset.item;

    console.log('📁 显示商品移动模态框:', item);

    this.setData({
      showMoveModal: true,
      currentMoveProduct: item,
      selectedMoveCategory: null
    });
  },

  // 隐藏商品移动模态框
  hideMoveModal() {
    this.setData({
      showMoveModal: false,
      currentMoveProduct: null,
      selectedMoveCategory: null
    });
  },

  // 显示删除确认弹窗
  showDeleteConfirm(e) {
    const item = e.currentTarget.dataset.item;
    const section = e.currentTarget.dataset.section;

    console.log('🗑️ 显示删除确认弹窗:', { item, section });

    this.setData({
      showDeleteConfirm: true,
      deleteTargetProduct: item,
      deleteTargetSection: section
    });
  },

  // 隐藏删除确认弹窗
  hideDeleteConfirm() {
    this.setData({
      showDeleteConfirm: false,
      deleteTargetProduct: null,
      deleteTargetSection: null
    });
  },

  // 确认删除商品
  confirmDeleteProduct() {
    const { deleteTargetProduct, deleteTargetSection } = this.data;

    if (!deleteTargetProduct || !deleteTargetSection) {
      console.error('❌ 删除参数不完整');
      return;
    }

    console.log('🗑️ 确认删除商品:', {
      product: deleteTargetProduct.productName,
      section: deleteTargetSection,
      favoriteId: deleteTargetProduct.favoriteId
    });

    try {
      // 从对应分区中移除商品
      this.removeProductFromSection(deleteTargetProduct, deleteTargetSection);

      // 显示成功提示
      wx.showToast({
        title: '已从衣柜移除',
        icon: 'success',
        duration: 2000
      });

      // 隐藏弹窗
      this.hideDeleteConfirm();

      console.log('✅ 商品删除成功');

    } catch (error) {
      console.error('❌ 删除商品失败:', error);
      wx.showToast({
        title: '删除失败',
        icon: 'error'
      });
    }
  },

  // 从指定分区移除商品
  removeProductFromSection(product, sectionName) {
    console.log('🗑️ 从分区移除商品:', { product: product.productName, section: sectionName });

    // 获取当前的分区商品数据
    const currentSectionProducts = { ...this.data.sectionProducts };

    if (!currentSectionProducts[sectionName]) {
      console.error('❌ 无效的分区名称:', sectionName);
      return;
    }

    // 从指定分区中移除商品
    currentSectionProducts[sectionName] = currentSectionProducts[sectionName].filter(
      item => item.favoriteId !== product.favoriteId
    );

    // 更新页面数据
    this.setData({
      sectionProducts: currentSectionProducts
    });

    // 更新本地存储
    this.saveWardrobeSectionItems(currentSectionProducts);

    console.log('✅ 商品已从分区移除:', {
      section: sectionName,
      remainingCount: currentSectionProducts[sectionName].length
    });
  },

  // 选择移动目标分类
  selectMoveCategory(e) {
    const categoryId = e.currentTarget.dataset.categoryId;

    console.log('📁 选择移动目标分类:', categoryId);

    this.setData({
      selectedMoveCategory: categoryId
    });
  },

  // 确认移动商品到分类
  async confirmMoveProduct() {
    if (!this.data.currentMoveProduct || !this.data.selectedMoveCategory) {
      wx.showToast({
        title: '请选择目标分类',
        icon: 'none'
      });
      return;
    }

    try {
      wx.showLoading({
        title: '移动中...',
        mask: true
      });

      const app = getApp();
      const token = app.globalData.token;

      if (!token) {
        wx.hideLoading();
        wx.showToast({
          title: '请先登录',
          icon: 'none'
        });
        return;
      }

      // 调用移动商品到分类的API
      await this.moveProductToCategoryAPI(
        token,
        this.data.currentMoveProduct.favoriteId,
        this.data.selectedMoveCategory
      );

      // 更新本地数据
      const updatedItems = this.data.wardrobeItems.map(item => {
        if (item.favoriteId === this.data.currentMoveProduct.favoriteId) {
          // 找到目标分类名称
          const targetCategory = this.data.wardrobeCategories.find(cat =>
            cat.categoryId === this.data.selectedMoveCategory
          );

          return {
            ...item,
            categoryId: this.data.selectedMoveCategory,
            categoryName: targetCategory ? targetCategory.categoryName : '未知分类'
          };
        }
        return item;
      });

      this.setData({
        wardrobeItems: updatedItems,
        currentWardrobeItems: updatedItems
      });

      // 更新分类商品数量
      this.updateCategoryProductCount();

      // 重新筛选当前显示的商品
      this.filterWardrobeItemsByCategory(this.data.selectedCategory);

      wx.hideLoading();
      this.hideMoveModal();

      wx.showToast({
        title: '移动成功',
        icon: 'success'
      });

      console.log('✅ 商品移动成功');

    } catch (error) {
      console.error('❌ 移动商品失败:', error);
      wx.hideLoading();
      wx.showToast({
        title: error.message || '移动失败',
        icon: 'none'
      });
    }
  },

  // 调用移动商品到分类API
  moveProductToCategoryAPI(token, favoriteId, categoryId) {
    const app = getApp();

    return new Promise((resolve, reject) => {
      console.log('🔄 调用移动商品到分类API');
      console.log('favoriteId:', favoriteId, 'categoryId:', categoryId);

      wx.request({
        url: `${app.globalData.baseUrl}/wardrobe/favorites/${favoriteId}/category`,
        method: 'PUT',
        timeout: 30000,
        header: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        },
        data: {
          categoryId: categoryId
        },
        success: (res) => {
          console.log('📥 移动商品API响应:', res);

          if (res.statusCode === 200 && res.data && res.data.code === 1) {
            resolve(res.data);
          } else {
            reject(new Error(res.data?.msg || '移动失败'));
          }
        },
        fail: (error) => {
          console.error('❌ 移动商品API网络失败:', error);
          reject(new Error('网络请求失败: ' + error.errMsg));
        }
      });
    });
  },

  // 头像组件选择事件
  onAvatarSelect(e) {
    const { item } = e.detail;
    console.log('👤 头像组件选择事件:', item);

    // 设置选中的脸部素材
    this.setData({
      selectedFace: item.id,
      customFaceImage: null, // 清除自定义上传的图片
      customFaceThumbnail: null, // 清除缩略图
      customFaceMaterialId: null // 清除自定义素材ID
    });
  },

  // 头像组件上传事件
  onAvatarUpload(e) {
    console.log('👤 头像组件上传事件');
    this.uploadFaceImage();
  },

  // 头像组件弹窗显示事件
  onAvatarModalShow(e) {
    console.log('👤 头像组件弹窗显示');
    // 初始化临时选择状态为当前选择
    this.setData({
      showAvatarModal: true,
      tempSelectedFace: this.data.selectedFace,
      tempSelectedFaceName: this.getTempSelectedFaceName(),
      tempCustomFaceImage: !!this.data.customFaceImage && !this.data.selectedFace
    });
  },

  // 头像组件弹窗隐藏事件
  onAvatarModalHide(e) {
    console.log('👤 头像组件弹窗隐藏');
    this.setData({
      showAvatarModal: false
    });
  },

  // 显示我的形象弹窗
  showAvatarModal() {
    console.log('👤 显示我的形象弹窗');
    this.setData({
      showAvatarModal: true
    });
  },

  // 隐藏我的形象弹窗
  hideAvatarModal() {
    console.log('👤 隐藏我的形象弹窗');
    this.setData({
      showAvatarModal: false
    });
  },

  // 阻止事件冒泡
  stopPropagation() {
    // 空方法，用于阻止事件冒泡
  },

  // 获取临时选择的人脸名称
  getTempSelectedFaceName() {
    if (this.data.selectedFace) {
      const selectedItem = this.data.faceList.find(item => item.id === this.data.selectedFace);
      return selectedItem ? selectedItem.name : '';
    }
    return '';
  },

  // 临时选择脸部素材（弹窗中的预选择）
  selectTempFaceMaterial(e) {
    const item = e.currentTarget.dataset.item;
    if (!item) {
      console.error('脸部素材数据为空');
      return;
    }

    console.log('👤 临时选择脸部素材:', {
      id: item.id,
      name: item.name
    });

    this.setData({
      tempSelectedFace: item.id,
      tempSelectedFaceName: item.name,
      tempCustomFaceImage: false
    });

    // 触觉反馈
    wx.vibrateShort({
      type: 'light'
    });
  },

  // 选择自定义人脸
  selectCustomFace() {
    if (!this.data.customFaceImage) {
      // 如果没有自定义图片，直接触发上传
      this.uploadFaceImage();
      return;
    }

    console.log('👤 临时选择自定义人脸');
    this.setData({
      tempSelectedFace: null,
      tempSelectedFaceName: '',
      tempCustomFaceImage: true
    });

    // 触觉反馈
    wx.vibrateShort({
      type: 'light'
    });
  },

  // 确认选择
  confirmFaceSelection() {
    const { tempSelectedFace, tempCustomFaceImage } = this.data;
    
    if (!tempSelectedFace && !tempCustomFaceImage) {
      wx.showToast({
        title: '请先选择一个形象',
        icon: 'none'
      });
      return;
    }

    console.log('✅ 确认选择形象:', {
      tempSelectedFace,
      tempCustomFaceImage
    });

    // 更新实际选择状态
    if (tempCustomFaceImage) {
      this.setData({
        selectedFace: null,
        selectedFaceImage: null,
        showAvatarModal: false,
        tempSelectedFace: null,
        tempSelectedFaceName: '',
        tempCustomFaceImage: false
      });
      
      wx.showToast({
        title: '已选择自定义人脸',
        icon: 'success'
      });
    } else {
      const selectedItem = this.data.faceList.find(item => item.id === tempSelectedFace);
      this.setData({
        selectedFace: tempSelectedFace,
        selectedFaceImage: selectedItem ? (selectedItem.thumbnailUrl || selectedItem.imageUrl) : null,
        showAvatarModal: false,
        tempSelectedFace: null,
        tempSelectedFaceName: '',
        tempCustomFaceImage: false
      });

      wx.showToast({
        title: `已选择：${selectedItem ? selectedItem.name : ''}`,
        icon: 'success'
      });
    }

    // 触觉反馈
    wx.vibrateShort({
      type: 'medium'
    });

    console.log('✅ 形象选择确认完成');
  },

  // 从缓存加载上传的头像
  loadUploadedAvatarFromCache() {
    try {
      const uploadedAvatarUrl = wx.getStorageSync('uploadedAvatarUrl');
      const uploadedAvatarThumbnail = wx.getStorageSync('uploadedAvatarThumbnail');
      
      if (uploadedAvatarUrl) {
        console.log('📱 从缓存恢复上传的头像:', uploadedAvatarUrl);
        
        this.setData({
          customFaceImage: uploadedAvatarUrl,
          customFaceThumbnail: uploadedAvatarThumbnail || uploadedAvatarUrl,
          customFaceMaterialId: uploadedAvatarUrl,
          selectedFace: null,
          selectedFaceImage: null
        });
        
        console.log('✅ 缓存头像恢复完成');
      } else {
        console.log('💡 缓存中没有找到上传的头像');
      }
    } catch (error) {
      console.error('❌ 从缓存加载头像失败:', error);
    }
  },

  // 获取当前有效的人脸配置（用于换脸）
  getCurrentFaceConfig() {
    const config = {
      hasSelection: false,
      faceImageUrl: null,
      materialId: null,
      type: null,
      name: null
    };

    if (this.data.customFaceImage) {
      // 优先使用自定义上传的人脸
      config.hasSelection = true;
      config.faceImageUrl = this.data.customFaceImage;
      config.materialId = this.data.customFaceMaterialId || this.data.customFaceImage;
      config.type = 'custom';
      config.name = '自定义人脸';
    } else if (this.data.selectedFace) {
      // 使用预设脸部素材
      const selectedFaceMaterial = this.data.faceList.find(face => face.id === this.data.selectedFace);
      if (selectedFaceMaterial) {
        config.hasSelection = true;
        config.faceImageUrl = selectedFaceMaterial.imageUrl;
        config.materialId = selectedFaceMaterial.id;
        config.type = 'preset';
        config.name = selectedFaceMaterial.name;
      }
    }

    console.log('🎭 当前人脸配置:', config);
    return config;
  },



  // 选择脸部素材
  selectFaceMaterial(e) {
    const item = e.currentTarget.dataset.item;
    if (!item) {
      console.error('脸部素材数据为空');
      return;
    }

    console.log('👤 选择脸部素材:', {
      id: item.id,
      name: item.name,
      imageUrl: item.imageUrl,
      thumbnailUrl: item.thumbnailUrl
    });

    // 设置选中的脸部素材
    this.setData({
      selectedFace: item.id,
      customFaceImage: null, // 清除自定义上传的图片
      customFaceThumbnail: null, // 清除缩略图
      customFaceMaterialId: null, // 清除自定义素材ID
      showFaceMaterialsModal: false // 选择后关闭弹窗
    });

    wx.showToast({
      title: `已选择：${item.name}`,
      icon: 'success',
      duration: 1500
    });

    console.log('✅ 脸部素材选择完成');
  },

  // 显示分类管理模态框
  showCategoryModal() {
    console.log('⚙️ 显示分类管理模态框');

    this.setData({
      showCategoryModal: true,
      newCategoryName: ''
    });
  },

  // 隐藏分类管理模态框
  hideCategoryModal() {
    this.setData({
      showCategoryModal: false,
      newCategoryName: ''
    });
  },

  // 新分类名称输入
  onNewCategoryNameInput(e) {
    this.setData({
      newCategoryName: e.detail.value.trim()
    });
  },

  // 添加新分类
  async addNewCategory() {
    if (!this.data.newCategoryName) {
      wx.showToast({
        title: '请输入分类名称',
        icon: 'none'
      });
      return;
    }

    // 检查分类名称是否重复
    const existingCategory = this.data.wardrobeCategories.find(cat =>
      cat.categoryName === this.data.newCategoryName
    );

    if (existingCategory) {
      wx.showToast({
        title: '分类名称已存在',
        icon: 'none'
      });
      return;
    }

    try {
      wx.showLoading({
        title: '添加中...',
        mask: true
      });

      const app = getApp();
      const token = app.globalData.token;

      if (!token) {
        wx.hideLoading();
        wx.showToast({
          title: '请先登录',
          icon: 'none'
        });
        return;
      }

      // 调用添加分类API
      const result = await this.addCategoryAPI(token, this.data.newCategoryName);

      if (result && result.code === 1 && result.data) {
        // 添加到本地分类列表
        const newCategory = {
          categoryId: result.data.categoryId,
          categoryName: result.data.categoryName,
          productCount: 0
        };

        this.setData({
          wardrobeCategories: [...this.data.wardrobeCategories, newCategory],
          newCategoryName: ''
        });

        wx.hideLoading();
        wx.showToast({
          title: '分类添加成功',
          icon: 'success'
        });

        console.log('✅ 新分类添加成功:', newCategory);
      } else {
        throw new Error(result?.msg || '添加分类失败');
      }

    } catch (error) {
      console.error('❌ 添加分类失败:', error);
      wx.hideLoading();
      wx.showToast({
        title: error.message || '添加失败',
        icon: 'none'
      });
    }
  },

  // 调用添加分类API
  addCategoryAPI(token, categoryName) {
    const app = getApp();

    return new Promise((resolve, reject) => {
      console.log('🔄 调用添加分类API');
      console.log('分类名称:', categoryName);

      wx.request({
        url: `${app.globalData.baseUrl}/wardrobe/categories`,
        method: 'POST',
        timeout: 30000,
        header: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        },
        data: {
          categoryName: categoryName
        },
        success: (res) => {
          console.log('📥 添加分类API响应:', res);
          resolve(res.data);
        },
        fail: (error) => {
          console.error('❌ 添加分类API网络失败:', error);
          reject(new Error('网络请求失败: ' + error.errMsg));
        }
      });
    });
  },

  // 编辑分类
  editCategory(e) {
    const category = e.currentTarget.dataset.category;

    console.log('✏️ 编辑分类:', category);

    this.setData({
      showEditCategoryModal: true,
      currentEditCategory: category,
      editCategoryName: category.categoryName
    });
  },

  // 隐藏编辑分类模态框
  hideEditCategoryModal() {
    this.setData({
      showEditCategoryModal: false,
      currentEditCategory: null,
      editCategoryName: ''
    });
  },

  // 编辑分类名称输入
  onEditCategoryNameInput(e) {
    this.setData({
      editCategoryName: e.detail.value.trim()
    });
  },

  // 确认编辑分类
  async confirmEditCategory() {
    if (!this.data.editCategoryName) {
      wx.showToast({
        title: '请输入分类名称',
        icon: 'none'
      });
      return;
    }

    if (this.data.editCategoryName === this.data.currentEditCategory.categoryName) {
      this.hideEditCategoryModal();
      return;
    }

    // 检查分类名称是否重复
    const existingCategory = this.data.wardrobeCategories.find(cat =>
      cat.categoryName === this.data.editCategoryName &&
      cat.categoryId !== this.data.currentEditCategory.categoryId
    );

    if (existingCategory) {
      wx.showToast({
        title: '分类名称已存在',
        icon: 'none'
      });
      return;
    }

    try {
      wx.showLoading({
        title: '保存中...',
        mask: true
      });

      const app = getApp();
      const token = app.globalData.token;

      // 调用编辑分类API
      const result = await this.editCategoryAPI(
        token,
        this.data.currentEditCategory.categoryId,
        this.data.editCategoryName
      );

      if (result && result.code === 1) {
        // 更新本地分类列表
        const updatedCategories = this.data.wardrobeCategories.map(cat => {
          if (cat.categoryId === this.data.currentEditCategory.categoryId) {
            return {
              ...cat,
              categoryName: this.data.editCategoryName
            };
          }
          return cat;
        });

        // 更新衣橱商品中的分类名称
        const updatedItems = this.data.wardrobeItems.map(item => {
          if (item.categoryId === this.data.currentEditCategory.categoryId) {
            return {
              ...item,
              categoryName: this.data.editCategoryName
            };
          }
          return item;
        });

        this.setData({
          wardrobeCategories: updatedCategories,
          wardrobeItems: updatedItems,
          currentWardrobeItems: updatedItems
        });

        wx.hideLoading();
        this.hideEditCategoryModal();

        wx.showToast({
          title: '分类编辑成功',
          icon: 'success'
        });

        console.log('✅ 分类编辑成功');
      } else {
        throw new Error(result?.msg || '编辑分类失败');
      }

    } catch (error) {
      console.error('❌ 编辑分类失败:', error);
      wx.hideLoading();
      wx.showToast({
        title: error.message || '编辑失败',
        icon: 'none'
      });
    }
  },

  // 调用编辑分类API
  editCategoryAPI(token, categoryId, categoryName) {
    const app = getApp();

    return new Promise((resolve, reject) => {
      console.log('🔄 调用编辑分类API');
      console.log('分类ID:', categoryId, '新名称:', categoryName);

      wx.request({
        url: `${app.globalData.baseUrl}/wardrobe/categories/${categoryId}`,
        method: 'PUT',
        timeout: 30000,
        header: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        },
        data: {
          categoryName: categoryName
        },
        success: (res) => {
          console.log('📥 编辑分类API响应:', res);
          resolve(res.data);
        },
        fail: (error) => {
          console.error('❌ 编辑分类API网络失败:', error);
          reject(new Error('网络请求失败: ' + error.errMsg));
        }
      });
    });
  },

  // 删除分类
  deleteCategory(e) {
    const category = e.currentTarget.dataset.category;

    console.log('🗑️ 删除分类:', category);

    // 检查分类下是否有商品
    const hasProducts = this.data.wardrobeItems.some(item =>
      item.categoryId === category.categoryId
    );

    let content = `确定要删除分类"${category.categoryName}"吗？`;
    if (hasProducts) {
      content = `分类"${category.categoryName}"下还有${category.productCount}件商品，删除后这些商品将移动到"未分类"。确定要删除吗？`;
    }

    wx.showModal({
      title: '确认删除',
      content: content,
      confirmText: '删除',
      confirmColor: '#d32f2f',
      success: async (res) => {
        if (res.confirm) {
          await this.performDeleteCategory(category);
        }
      }
    });
  },

  // 执行删除分类
  async performDeleteCategory(category) {
    try {
      wx.showLoading({
        title: '删除中...',
        mask: true
      });

      const app = getApp();
      const token = app.globalData.token;

      // 调用删除分类API
      const result = await this.deleteCategoryAPI(token, category.categoryId);

      if (result && result.code === 1) {
        // 从本地分类列表中移除
        const updatedCategories = this.data.wardrobeCategories.filter(cat =>
          cat.categoryId !== category.categoryId
        );

        // 将该分类下的商品移动到"未分类"（categoryId: 0）
        const updatedItems = this.data.wardrobeItems.map(item => {
          if (item.categoryId === category.categoryId) {
            return {
              ...item,
              categoryId: 0,
              categoryName: '未分类'
            };
          }
          return item;
        });

        this.setData({
          wardrobeCategories: updatedCategories,
          wardrobeItems: updatedItems,
          currentWardrobeItems: updatedItems
        });

        // 更新分类商品数量
        this.updateCategoryProductCount();

        // 如果当前选中的是被删除的分类，切换到全部
        if (this.data.selectedCategory === category.categoryId) {
          this.setData({
            selectedCategory: 0
          });
          this.filterWardrobeItemsByCategory(0);
        }

        wx.hideLoading();
        wx.showToast({
          title: '分类删除成功',
          icon: 'success'
        });

        console.log('✅ 分类删除成功');
      } else {
        throw new Error(result?.msg || '删除分类失败');
      }

    } catch (error) {
      console.error('❌ 删除分类失败:', error);
      wx.hideLoading();
      wx.showToast({
        title: error.message || '删除失败',
        icon: 'none'
      });
    }
  },

  // 调用删除分类API
  deleteCategoryAPI(token, categoryId) {
    const app = getApp();

    return new Promise((resolve, reject) => {
      console.log('🔄 调用删除分类API');
      console.log('分类ID:', categoryId);

      wx.request({
        url: `${app.globalData.baseUrl}/wardrobe/categories/${categoryId}`,
        method: 'DELETE',
        timeout: 30000,
        header: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        },
        success: (res) => {
          console.log('📥 删除分类API响应:', res);
          resolve(res.data);
        },
        fail: (error) => {
          console.error('❌ 删除分类API网络失败:', error);
          reject(new Error('网络请求失败: ' + error.errMsg));
        }
      });
    });
  },

  // 融合程度变化
  onFusionDegreeChange(e) {
    const fusionDegree = e.detail.value;
    this.setData({
      fusionDegree: fusionDegree
    });
    console.log('融合程度变化:', fusionDegree);
  },

  // 上传自定义脸部照片
  uploadFaceImage() {
    console.log('📤 开始上传自定义人脸照片');

    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: async (res) => {
        const tempFilePath = res.tempFilePaths[0];
        console.log('📷 选择的人脸图片路径', tempFilePath);

        // 验证文件格式
        const fileExtension = tempFilePath.split('.').pop().toLowerCase();
        const allowedFormats = ['jpg', 'jpeg', 'png'];

        if (!allowedFormats.includes(fileExtension)) {
          wx.showToast({
            title: `不支持${fileExtension.toUpperCase()}格式，请选择JPG或PNG图片`,
            icon: 'none',
            duration: 3000
          });
          return;
        }

        // 显示上传进度
        wx.showLoading({
          title: '上传人脸中..',
          mask: true
        });

        try {
          // 上传图片到腾讯云COS（用户上传的图片不保存到数据库）
          console.log('📤 上传人脸图片到腾讯云COS');
          const cosImageUrl = await this.uploadImageToCOS(tempFilePath, 'custom');
          console.log('✅图片上传到COS成功:', cosImageUrl);

          // 设置自定义人脸数据（直接使用COS图片URL作为materialId）
          this.setData({
            customFaceImage: cosImageUrl, // COS图片URL（用于前端回显）
            customFaceThumbnail: tempFilePath, // 本地缩略图用于预览
            customFaceMaterialId: cosImageUrl, // 直接使用图片URL作为materialId
            selectedFace: null, // 清除选择的素材
            selectedFaceImage: null // 清除选择的素材图片
          });

          // 将上传的头像保存到本地缓存
          wx.setStorageSync('uploadedAvatarUrl', cosImageUrl);
          wx.setStorageSync('uploadedAvatarThumbnail', tempFilePath);
          
          console.log('💾 头像已保存到缓存:', cosImageUrl);

          console.log('✅自定义人脸设置完成', {
            cosImageUrl: cosImageUrl,
            materialId: cosImageUrl,
            note: '用户上传的图片不保存到数据库，直接使用COS URL作为materialId'
          });

          wx.hideLoading();
          wx.showToast({
            title: '人脸上传成功',
            icon: 'success',
            duration: 2000
          });

        } catch (error) {
          console.error('?人脸图片上传失败:', error);
          wx.hideLoading();

          // 上传失败时的友好提示
          let errorMessage = '人脸上传失败';
          if (error.message) {
            if (error.message.includes('网络')) {
              errorMessage = '网络连接失败，请重试';
            } else if (error.message.includes('格式')) {
              errorMessage = '图片格式不支持，请选择JPG或PNG格式';
            } else if (error.message.includes('5MB')) {
              errorMessage = '图片太大，请选择小于5MB的图';
            } else if (error.message.includes('未检测到人脸')) {
              errorMessage = '未检测到人脸，请使用清晰的人脸图';
            } else if (error.message.includes('添加人脸素材')) {
              errorMessage = '添加人脸素材失败，请重试';
            } else {
              errorMessage = error.message;
            }
          }

          console.error('?人脸上传最终错?', errorMessage);

          wx.showToast({
            title: errorMessage,
            icon: 'none',
            duration: 3000
          });
        }
      },
      fail: (error) => {
        console.error('?选择图片失败:', error);
        wx.showToast({
          title: '选择图片失败',
          icon: 'none'
        });
      }
    });
  },








  // 调用百度云人脸融合API（直接使用两张图片）
  callBaiduFaceFusionAPI(templateImageUrl, targetImageUrl, fusionDegree, token) {
    const app = getApp();
    return new Promise((resolve, reject) => {
      console.log('🔄 调用百度云人脸融合API');
      console.log('模板图片（模特）:', templateImageUrl);
      console.log('目标图片（人脸）:', targetImageUrl);
      console.log('融合程度:', fusionDegree);
      console.log('API地址:', `${app.globalData.baseUrl}/ai/face-fusion`);

      // 验证必要参数
      if (!templateImageUrl) {
        reject(new Error('模板图片URL不能为空'));
        return;
      }

      if (!targetImageUrl) {
        reject(new Error('目标图片URL不能为空'));
        return;
      }

      // 构建请求参数（按照后端FaceFusionRequest格式））
      const requestData = {
        userImageUrl: templateImageUrl,      // 模特图片URL
        materialId: "mt_1951211355278942208", // 使用已知存在的素材ID
        fusionDegree: fusionDegree,          // 融合程度
        logoAdd: 0                           // 不添加AI标识
      };



      console.log('🔄 百度云人脸融合请求参数', JSON.stringify(requestData, null, 2));

      wx.request({
        url: `${app.globalData.baseUrl}/ai/face-fusion`,
        method: 'POST',
        timeout: 60000, // 增加超时时间，人脸融合可能需要更长时间
        header: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`
        },
        data: requestData,
        success: (res) => {
          console.log('📥 百度云人脸融合API响应:', res);
          console.log('📥 响应状态码:', res.statusCode);
          console.log('📥 响应数据:', res.data);

          try {
            let responseData;
            if (typeof res.data === 'string') {
              console.log('📥 解析字符串响应数据');
              responseData = JSON.parse(res.data);
            } else {
              console.log('📥 使用对象响应数据');
              responseData = res.data;
            }

            console.log('📥 解析后的响应数据:', JSON.stringify(responseData, null, 2));

            if (res.statusCode === 200 && responseData.code === 1) {
              console.log('✅百度云人脸融合API调用成功');

              // 检查响应数据结构构
              if (responseData.data) {
                console.log('🔍 检查响应数据结构');
                console.log('  - responseData.data:', responseData.data);
                console.log('  - responseData.data类型:', typeof responseData.data);
                console.log('  - responseData.data的所有键:', Object.keys(responseData.data));

                // 详细输出data内容
                console.log('  - 详细data内容:', JSON.stringify(responseData.data, null, 2));

                // 检查是否直接返回了结果图片
                if (responseData.data.resultImageUrl) {
                  console.log('✅直接返回结果图片:', responseData.data.resultImageUrl);
                  responseData.needQueryResult = false;
                  resolve(responseData);
                  return;
                }

                // 检查是否需要通过operationId查询结果
                if (responseData.data.operationId) {
                  console.log('🔄 需要通过operationId查询结果');
                  console.log('🔄 operationId:', responseData.data.operationId);
                  console.log('🔄 processingTime:', responseData.data.processingTime);
                  responseData.needQueryResult = true;
                  resolve(responseData);
                  return;
                }
              }

              // 如果没有找到预期的数据结构，返回原始响应
              console.log('⚠️ 未找到预期的数据结构，返回原始响应');
              resolve(responseData);
            } else {
              const errorMsg = responseData.msg || responseData.message || '百度云人脸融合失败';
              console.error('?百度云人脸融合业务逻辑失败:', errorMsg);
              console.error('?完整响应:', responseData);
              reject(new Error(errorMsg));
            }
          } catch (parseError) {
            console.error('?解析百度云人脸融合响应失?', parseError);
            console.error('?原始响应:', res.data);
            reject(new Error('服务器响应格式错误'));
          }
        },
        fail: (error) => {
          console.error('?百度云人脸融合网络失?', error);

          let errorMessage = '网络请求失败';
          if (error.errMsg) {
            if (error.errMsg.includes('timeout')) {
              errorMessage = '人脸融合处理超时，请重试';
            } else if (error.errMsg.includes('fail')) {
              errorMessage = '网络连接失败，请检查网';
            } else {
              errorMessage = error.errMsg;
            }
          }

          reject(new Error(errorMessage));
        }
      });
    });
  },
  // 开始换脸
  async startFaceSwap() {
    console.log('👤 startFaceSwap 被调用');

    // 检查算力余额额
    if (this.data.userEnergy < 1) {
      wx.showModal({
        title: '算力不足',
        content: '您的算力余额不足，请联系管理员充',
        showCancel: false
      });
      return;
    }

    // 检查是否选择了脸部素材或上传了照片片
    if (!this.data.selectedFace && !this.data.customFaceImage) {
      wx.showToast({
        title: '请选择脸部素材或上传照',
        icon: 'none'
      });
      return;
    }

    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    console.log('👤 开始换脸', {
      selectedFace: this.data.selectedFace,
      customFaceImage: this.data.customFaceImage,
      modelImage: this.data.modelImage,
      fusionDegree: this.data.fusionDegree
    });

    // 显示AI处理动画
    this.setData({
      aiProcessing: true,
      aiProgress: 0,
      aiOperationType: 'face'
    });

    // 模拟进度条动画画
    const progressTimer = setInterval(() => {
      const currentProgress = this.data.aiProgress;
      if (currentProgress < 85) {
        if (currentProgress < 30) {
          this.setData({
            aiProgress: currentProgress + 10
          });
        } else if (currentProgress < 60) {
          this.setData({
            aiProgress: currentProgress + 5
          });
        } else {
          this.setData({
            aiProgress: currentProgress + 2
          });
        }
      }
    }, 500);

    try {
      // 验证必要参数
      if (!this.data.modelImage) {
        throw new Error('请先上传模特图片');
      }

      // 获取人脸信息
      let materialId = null;

      if (this.data.customFaceImage) {
        // 使用自定义上传的人脸图片
        materialId = this.data.customFaceImage; // 直接使用图片URL作为materialId

        console.log('👤 使用自定义人脸图片', {
          customFaceImage: this.data.customFaceImage,
          materialId: materialId,
          note: '使用自定义上传的人脸图片URL作为materialId'
        });
      } else if (this.data.selectedFace) {
        // 使用预设脸部素材
        const selectedFaceMaterial = this.data.faceList.find(face => face.id === this.data.selectedFace);
        if (!selectedFaceMaterial) {
          throw new Error('未找到选择的脸部素');
        }
        materialId = selectedFaceMaterial.id;

        console.log('👤 使用预设脸部素材:', {
          materialId: materialId,
          material: selectedFaceMaterial
        });
      } else {
        throw new Error('请选择脸部素材或上传自定义人脸');
      }

      // 验证原始图片URL
      if (!this.data.modelImage.startsWith('http://') && !this.data.modelImage.startsWith('https://')) {
        throw new Error('原始图片URL格式错误');
      }

      console.log('👤 准备调用人脸融合API:');
      console.log('  - 模特图片（userImageUrl）', this.data.modelImage);
      console.log('  - 素材ID（materialId）', materialId);
      console.log('  - 融合程度:', this.data.fusionDegree);
      console.log('  - Token:', token ? `已提供(${token.length}字符)` : '未提供');

      // 详细验证参数
      if (!this.data.modelImage || typeof this.data.modelImage !== 'string') {
        throw new Error('模特图片URL无效');
      }

      if (!materialId) {
        throw new Error('素材ID无效');
      }

      if (this.data.fusionDegree < 0 || this.data.fusionDegree > 100) {
        throw new Error('融合程度必须在0-100之间');
      }

      // 调用人脸融合API（使用简化版本）
      const result = await this.callSimpleFaceFusionAPI(this.data.modelImage, materialId, this.data.fusionDegree, token);

      // 清除进度条定时器
      clearInterval(progressTimer);

      console.log('👤 API返回结果:', result);

      if (result && result.code === 1) {
        // 检查是否直接返回了结果图片
        if (result.data && result.data.resultImageUrl) {
          //  完成进度
          // 完成进度条条
          this.setData({
            aiProgress: 100
          });

          // 延迟一下显示完成效果
          setTimeout(() => {
            //  换脸成功，更新模特图
            // 换脸成功，更新模特图片片
            this.setData({
              modelImage: result.data.resultImageUrl,
              aiProcessing: false,
              aiProgress: 0,
              aiOperationType: 'face'
            });

            //  换脸成功后，重新获取用户信息以同步算
            // 换脸成功后，重新获取用户信息以同步算力力
            this.refreshUserInfo();

            wx.showToast({
              title: '换脸完成',
              icon: 'success'
            });

            console.log('✅换脸成功，新图片:', result.data.resultImageUrl);
          }, 500);
        }
        // 检查是否需要通过operationId查询结果
        else if (result.needQueryResult && result.data && result.data.operationId) {
          console.log('🔄 需要通过operationId查询结果:', result.data.operationId);
          console.log('🔄 当前processingTime:', result.data.processingTime);

          //  继续显示进度条，开始查询结
          // 继续显示进度条，开始查询结果果
          this.setData({
            aiProgress: 60
          });

          try {
            // 根据processingTime决定等待时间
            const waitTime = result.data.processingTime > 0 ? 1000 : 3000;
            console.log(`🔄 等待 ${waitTime}ms 后查询结果`);
            await new Promise(resolve => setTimeout(resolve, waitTime));

            // 更新进度
            this.setData({
              aiProgress: 80
            });

            // 查询操作结果
            console.log('🔄 开始查询操作结果..');
            const operationResult = await this.queryOperationResult(result.data.operationId, token);

            console.log('📥 操作结果查询响应:', operationResult);

            // 检查操作状态和结果图片
            let finalImageUrl = null;
            if (operationResult && operationResult.data) {
              console.log('🔍 检查操作状态', operationResult.data.status);
              console.log('🔍 错误信息:', operationResult.data.errorMessage);

              // 检查操作是否成功功
              if (operationResult.data.status === 1) {
                // 操作成功，获取结果图片                finalImageUrl = operationResult.data.resultImageUrl;
                if (finalImageUrl) {
                  console.log(`✅操作成功，找到结果图片 ${finalImageUrl}`);
                } else {
                  console.log('⚠️ 操作成功但未找到结果图片URL');
                }
              } else if (operationResult.data.status === 0) {
                // 操作失败
                const errorMsg = operationResult.data.errorMessage || '操作处理失败';
                console.error('?操作失败:', errorMsg);
                throw new Error(`操作处理失败: ${errorMsg}`);
              } else {
                // 状态未知，尝试多种字段名
                console.log('🔍 状态未知，尝试多种字段名');
                const imageFields = ['resultImageUrl', 'result_image_url', 'imageUrl', 'url', 'fusedImage'];
                for (const field of imageFields) {
                  if (operationResult.data[field]) {
                    finalImageUrl = operationResult.data[field];
                    console.log(`✅在查询结果中找到图片字段: ${field} = ${finalImageUrl}`);
                    break;
                  }
                }
              }
            }

            if (finalImageUrl) {
              //  完成进度
              // 完成进度条条
              this.setData({
                aiProgress: 100
              });

              // 延迟一下显示完成效果
              setTimeout(() => {
                //  换脸成功，更新模特图
                // 换脸成功，更新模特图片片
                this.setData({
                  modelImage: finalImageUrl,
                  aiProcessing: false,
                  aiProgress: 0,
                  aiOperationType: 'face'
                });

                //  换脸成功后，重新获取用户信息以同步算
                // 换脸成功后，重新获取用户信息以同步算力力
                this.refreshUserInfo();

                wx.showToast({
                  title: '换脸完成',
                  icon: 'success'
                });

                console.log('✅通过operationId查询换脸成功，新图片:', finalImageUrl);
              }, 500);
            } else {
              console.error('?查询操作结果中未找到图片URL');
              console.error('?完整查询结果:', operationResult);
              throw new Error('查询操作结果失败：未找到结果图片');
            }
          } catch (queryError) {
            console.error('?查询操作结果失败:', queryError);
            throw new Error('换脸处理失败：' + queryError.message);
          }
        } else {
          // 既没有直接结果，也没有operationId
          const errorMsg = result && result.msg ? result.msg : '换脸失败，请重试';
          console.error('?API返回错误:', errorMsg);
          throw new Error(errorMsg);
        }
      } else {
        // 处理API返回的错误误
        const errorMsg = result && result.msg ? result.msg : '换脸失败，请重试';
        console.error('?API返回错误:', errorMsg);
        throw new Error(errorMsg);
      }
    } catch (error) {
      console.error('?换脸失败:', error);

      // 清除进度条定时器
      if (progressTimer) {
        clearInterval(progressTimer);
      }

      //  重置状态
      // 重置状态态
      this.setData({
        aiProcessing: false,
        aiProgress: 0,
        aiOperationType: 'face'
      });

      // 显示用户友好的错误信息息
      let errorMessage = '换脸失败，请重试';
      if (error.message) {
        if (error.message.includes('网络')) {
          errorMessage = '网络连接失败，请检查网';
        } else if (error.message.includes('登录')) {
          errorMessage = '登录已过期，请重新登';
        } else if (error.message.includes('Token余额不足')) {
          errorMessage = '算力余额不足，请联系管理员充';
        } else if (error.message.includes('未检测到人脸')) {
          errorMessage = '未检测到人脸，请使用清晰的人脸图';
        } else if (error.message.includes('HTTP错误')) {
          errorMessage = `服务器错误: ${error.message}`;
        } else if (error.message.includes('URL格式错误')) {
          errorMessage = '图片地址格式错误，请重新上传';
        } else {
          errorMessage = `错误详情: ${error.message}`;
        }
      }

      console.error('?最终错误信?', errorMessage);

      wx.showToast({
        title: errorMessage,
        icon: 'none',
        duration: 3000
      });
    }
  },

  // 调用换脸API
  callFaceFusionAPI(sourceImageUrl, faceImageUrl, materialId, fusionDegree, token) {
    const app = getApp();
    return new Promise((resolve, reject) => {
      console.log('🔄 调用换脸API');
      console.log('原始图片:', sourceImageUrl);
      console.log('人脸图片:', faceImageUrl);
      console.log('素材ID:', materialId);
      console.log('融合程度:', fusionDegree);
      console.log('API地址:', `${app.globalData.baseUrl}/ai/face-fusion`);

      // 验证必要参数
      if (!sourceImageUrl) {
        reject(new Error('原始图片URL不能为空'));
        return;
      }

      if (!materialId) {
        reject(new Error('素材ID不能为空'));
        return;
      }

      // 构建请求参数（严格按照后端FaceFusionRequest格式））
      const requestData = {
        userImageUrl: sourceImageUrl,        // 模特图片URL
        materialId: String(materialId),      // 素材ID
        fusionDegree: fusionDegree,          // 融合程度
        logoAdd: 0                           // 不添加AI标识
      };

      // 添加可选参数数
      if (fusionDegree !== undefined && fusionDegree !== null) {
        requestData.fusionDegree = Number(fusionDegree);
      }

      // 添加logoAdd参数（API文档中的可选参数）
      requestData.logoAdd = 0; // 不添加AI标识

      console.log('🔄 最终请求参数', JSON.stringify(requestData, null, 2));
      console.log('🔄 请求头信息', {
        'Content-Type': 'application/json',
        'Authorization': token ? `Bearer ${token.substring(0, 20)}...` : '未提供'
      });

      wx.request({
        url: `${app.globalData.baseUrl}/ai/face-fusion`,
        method: 'POST',
        timeout: 60000, // 设置超时时间2分钟
        header: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`
        },
        data: requestData,
        success: (res) => {
          console.log('📥 换脸API响应:', res);
          console.log('响应状态码:', res.statusCode);
          console.log('响应数据:', res.data);

          // 详细分析响应数据
          if (res.statusCode !== 200) {
            console.error('?HTTP状态码错误:', res.statusCode);
            console.error('?响应?', res.header);
            console.error('?响应数据:', res.data);

            // 尝试解析400错误的详细信息
            let errorDetail = `HTTP错误: ${res.statusCode}`;
            if (res.data) {
              try {
                let errorData;
                if (typeof res.data === 'string') {
                  errorData = JSON.parse(res.data);
                } else {
                  errorData = res.data;
                }

                if (errorData.msg || errorData.message) {
                  errorDetail = errorData.msg || errorData.message;
                } else if (errorData.error) {
                  errorDetail = errorData.error;
                }

                console.error('?解析后的错误信息:', errorDetail);
              } catch (parseError) {
                console.error('?无法解析错误响应:', parseError);
                errorDetail = `HTTP错误: ${res.statusCode} - ${res.data}`;
              }
            }

            reject(new Error(errorDetail));
            return;
          }

          // 检查响应数据格式式
          if (!res.data) {
            console.error('?响应数据为空');
            reject(new Error('服务器响应数据为空'));
            return;
          }

          // 尝试解析响应数据
          let responseData;
          try {
            if (typeof res.data === 'string') {
              responseData = JSON.parse(res.data);
            } else {
              responseData = res.data;
            }
          } catch (parseError) {
            console.error('?响应数据解析失败:', parseError);
            console.error('原始响应数据:', res.data);
            reject(new Error('服务器响应格式错误'));
            return;
          }

          console.log('📥 解析后的响应数据:', responseData);

          // 检查业务逻辑错误
          if (responseData.code !== 1) {
            console.error('?业务逻辑错误:', responseData);
            const errorMsg = responseData.msg || responseData.message || '换脸失败，请重试';
            reject(new Error(errorMsg));
            return;
          }

          // 详细检查响应数据结构
          console.log('🔍 检查响应数据结构');
          console.log('  - responseData.data:', responseData.data);
          console.log('  - responseData.data类型:', typeof responseData.data);
          console.log('  - responseData.data的所有键:', responseData.data ? Object.keys(responseData.data) : '无');

          if (responseData.data) {
            console.log('  - 详细data内容:', JSON.stringify(responseData.data, null, 2));
          }

          // 检查可能的结果图片字段名名
          const possibleImageFields = ['resultImageUrl', 'imageUrl', 'url', 'result_image_url', 'fusedImage'];
          let resultImageUrl = null;

          if (responseData.data) {
            for (const field of possibleImageFields) {
              if (responseData.data[field]) {
                resultImageUrl = responseData.data[field];
                console.log(`✅找到结果图片字段: ${field} = ${resultImageUrl}`);
                break;
              }
            }
          }

          // 如果找到了结果图片，直接返回
          if (resultImageUrl && responseData.data) {
            responseData.data.resultImageUrl = resultImageUrl;
            console.log('✅找到结果图片，直接返回', resultImageUrl);
            resolve(responseData);
            return;
          }

          // 如果没有找到结果图片，但有operationId，标记需要查询结果
          if (responseData.data && responseData.data.operationId) {
            console.log('🔄 没有直接返回结果图片，需要通过operationId查询结果');
            console.log('🔄 operationId:', responseData.data.operationId);
            console.log('🔄 processingTime:', responseData.data.processingTime);

            // 标记需要查询结果，让上层处理operationId查询
            responseData.needQueryResult = true;
            resolve(responseData);
            return;
          }

          // 既没有结果图片，也没有operationId，这是真正的错误
          console.error('?响应中既没有结果图片，也没有operationId');
          console.error('?尝试的字段名:', possibleImageFields);
          console.error('?完整响应数据:', responseData);
          reject(new Error('换脸处理失败：服务器未返回结果图片或操作ID'));
          return;
        },
        fail: (error) => {
          console.error('?换脸API网络失败:', error);
          console.error('错误详情:', JSON.stringify(error, null, 2));
          console.error('错误类型:', typeof error);
          console.error('错误消息:', error.errMsg);

          // 根据错误类型提供更友好的提示
          let errorMessage = '网络请求失败';
          if (error.errMsg) {
            if (error.errMsg.includes('timeout')) {
              errorMessage = '换脸处理超时，请稍后重试';
            } else if (error.errMsg.includes('fail')) {
              errorMessage = '网络连接失败，请检查网';
            } else if (error.errMsg.includes('request:fail')) {
              errorMessage = '请求失败，请检查网络连';
            } else {
              errorMessage = `网络错误: ${error.errMsg}`;
            }
          }

          reject(new Error(errorMessage));
        }
      });
    });
  },

  // 查询操作结果
  queryOperationResult(operationId, token) {
    const app = getApp();
    return new Promise((resolve, reject) => {
      console.log('🔄 查询操作结果，operationId:', operationId);

      wx.request({
        url: `${app.globalData.baseUrl}/ai/operations/${operationId}`,
        method: 'GET',
        timeout: 30000,
        header: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`
        },
        success: (res) => {
          console.log('📥 操作结果查询响应:', res);
          console.log('📥 响应状态码:', res.statusCode);
          console.log('📥 响应数据:', res.data);
          console.log('📥 响应数据类型:', typeof res.data);

          try {
            let responseData;
            if (typeof res.data === 'string') {
              console.log('📥 解析字符串响应数据');
              responseData = JSON.parse(res.data);
            } else {
              console.log('📥 使用对象响应数据');
              responseData = res.data;
            }

            console.log('📥 解析后的查询响应:', JSON.stringify(responseData, null, 2));

            if (res.statusCode === 200) {
              if (responseData.code === 1) {
                console.log('✅操作结果查询成功');
                console.log('✅查询结果data字段:', responseData.data);
                resolve(responseData);
              } else {
                const errorMsg = responseData.msg || responseData.message || '查询操作结果失败';
                console.error('?操作结果查询业务失败:', errorMsg);
                console.error('?完整响应:', responseData);
                reject(new Error(errorMsg));
              }
            } else {
              console.error('?操作结果查询HTTP错误:', res.statusCode);
              reject(new Error(`HTTP错误: ${res.statusCode}`));
            }
          } catch (parseError) {
            console.error('?解析操作结果响应失败:', parseError);
            console.error('?原始响应数据:', res.data);
            reject(new Error('服务器响应格式错误'));
          }
        },
        fail: (error) => {
          console.error('?操作结果查询网络失败:', error);
          reject(new Error('网络请求失败: ' + error.errMsg));
        }
      });
    });
  },



  // 切换商品收藏状态
  async toggleProductFavorite(e) {
    console.log('🔄 收藏按钮被点击');
    console.log('🔍 事件对象:', e);
    console.log('🔍 currentTarget:', e.currentTarget);
    console.log('🔍 dataset:', e.currentTarget.dataset);

    const item = e.currentTarget.dataset.item;
    if (!item) {
      console.error('❌ 商品数据为空');
      console.log('🔍 完整的dataset:', e.currentTarget.dataset);
      return;
    }

    console.log('✅ 获取到商品数据:', item);

    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      wx.showModal({
        title: '需要登录',
        content: '收藏功能需要登录后使用，是否前往登录？',
        confirmText: '去登录',
        cancelText: '稍后再说',
        success: (res) => {
          if (res.confirm) {
            // 使用reLaunch确保登录后能正确返回
            wx.reLaunch({
              url: '/pages/login/login'
            });
          }
        }
      });
      return;
    }

    // 获取商品ID，支持多种字段名
    const productId = item.productId || item.product_id || item.id || item.externalProductId;
    console.log('🔍 尝试获取商品ID:', {
      productId: item.productId,
      product_id: item.product_id,
      id: item.id,
      externalProductId: item.externalProductId,
      finalProductId: productId
    });

    if (!productId) {
      console.error('❌ 无法获取商品ID:', item);
      wx.showToast({
        title: '商品ID错误',
        icon: 'none'
      });
      return;
    }

    console.log('🔄 切换收藏状态:', {
      productId: productId,
      productName: item.productName || item.name,
      currentFavorited: item.favorited || item.isFavorite
    });

    // 设置加载状态
    this.updateProductLoadingState(productId, 'favoriteLoading', true);

    try {
      const isFavorited = item.favorited || item.isFavorite;

      if (isFavorited) {
        // 取消收藏
        const result = await this.removeFavoriteAPI(token, productId);
        if (result && result.code === 1) {
          this.updateProductFavoriteState(productId, false);
          wx.showToast({
            title: '已取消收藏',
            icon: 'success'
          });
          console.log('✅ 取消收藏成功');

          // 取消收藏成功后，刷新衣橱数据
          console.log('🔄 取消收藏成功，刷新衣橱数据');
          this.setData({
            wardrobeItemsLoaded: false
          });
          // 延迟刷新，确保后端数据已更新
          setTimeout(() => {
            this.loadWardrobeItems();
          }, 500);
        } else {
          throw new Error(result?.msg || '取消收藏失败');
        }
      } else {
        // 添加收藏
        console.log('🔄 开始添加收藏...');
        const result = await this.addFavoriteAPI(token, item);
        console.log('📥 添加收藏API响应:', result);

        if (result && result.code === 1) {
          this.updateProductFavoriteState(productId, true);
          wx.showToast({
            title: '已添加收藏',
            icon: 'success'
          });
          console.log('✅ 添加收藏成功');

          // 收藏成功后，刷新衣橱数据
          console.log('🔄 收藏成功，刷新衣橱数据');
          this.setData({
            wardrobeItemsLoaded: false
          });
          // 延迟刷新，确保后端数据已更新
          setTimeout(() => {
            this.loadWardrobeItems();
          }, 500);
        } else {
          console.error('❌ 添加收藏失败，响应:', result);
          throw new Error(result?.msg || '添加收藏失败');
        }
      }
    } catch (error) {
      console.error('❌ 切换收藏状态失败:', error);
      console.error('❌ 错误详情:', error.message);
      console.error('❌ 错误堆栈:', error.stack);

      wx.showToast({
        title: error.message || '操作失败',
        icon: 'none'
      });
    } finally {
      this.updateProductLoadingState(productId, 'favoriteLoading', false);
    }
  },

  // 查看商品详情
  viewProduct(e) {
    const item = e.currentTarget.dataset.item;
    if (!item) {
      console.error('商品数据为空');
      return;
    }

    console.log('🔍 查看商品详情:', {
      productId: item.productId || item.product_id || item.id,
      productName: item.productName || item.name
    });

    // 生成商品外部链接
    const externalLink = this.generateProductLink(item);

    if (externalLink) {
      wx.showModal({
        title: '查看商品',
        content: `商品：${item.productName || item.name}\n\n即将跳转到外部链接查看商品详情`,
        confirmText: '前往',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            // 复制链接到剪贴板
            wx.setClipboardData({
              data: externalLink,
              success: () => {
                wx.showToast({
                  title: '链接已复制到剪贴板',
                  icon: 'success'
                });
                console.log('✅ 商品链接已复制:', externalLink);
              },
              fail: (error) => {
                console.error('❌ 复制链接失败:', error);
                wx.showToast({
                  title: '复制失败',
                  icon: 'none'
                });
              }
            });
          }
        }
      });
    } else {
      wx.showToast({
        title: '暂无商品链接',
        icon: 'none'
      });
      console.warn('⚠️ 无法生成商品链接:', item);
    }
  },

  // 上传照片（模特图片）
  uploadPhoto() {
    console.log('📷 开始上传模特图片');

    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: async (res) => {
        const tempFilePath = res.tempFilePaths[0];
        console.log('📷 选择的图片路径:', tempFilePath);

        // 验证文件格式
        const fileExtension = tempFilePath.split('.').pop().toLowerCase();
        const allowedFormats = ['jpg', 'jpeg', 'png'];

        if (!allowedFormats.includes(fileExtension)) {
          wx.showToast({
            title: `不支持${fileExtension.toUpperCase()}格式，请选择JPG或PNG图片`,
            icon: 'none',
            duration: 3000
          });
          return;
        }

        wx.showModal({
          title: '上传模特图片',
          content: '确定要使用这张图片作为模特图片吗？图片将上传到云端以便进行AI换装。',
          confirmText: '确定上传',
          cancelText: '取消',
          success: async (modalRes) => {
            if (modalRes.confirm) {
              // 显示上传进度
              wx.showLoading({
                title: '上传模特图片中...',
                mask: true
              });

              try {
                // 上传图片到腾讯云COS
                console.log('📤 开始上传模特图片到腾讯云COS');
                const cosImageUrl = await this.uploadImageToCOS(tempFilePath, 'avatar');
                console.log('✅ 模特图片上传到COS成功:', cosImageUrl);

                // 更新模特图片
                this.setData({
                  modelImage: cosImageUrl
                });

                wx.hideLoading();
                wx.showToast({
                  title: '模特图片上传成功',
                  icon: 'success',
                  duration: 2000
                });

                console.log('✅ 模特图片设置完成:', cosImageUrl);

              } catch (error) {
                console.error('❌ 模特图片上传失败:', error);
                wx.hideLoading();

                // 上传失败时的友好提示
                let errorMessage = '模特图片上传失败';
                if (error.message) {
                  if (error.message.includes('网络')) {
                    errorMessage = '网络连接失败，请重试';
                  } else if (error.message.includes('格式')) {
                    errorMessage = '图片格式不支持，请选择JPG或PNG格式';
                  } else if (error.message.includes('5MB')) {
                    errorMessage = '图片太大，请选择小于5MB的图片';
                  } else {
                    errorMessage = error.message;
                  }
                }

                wx.showToast({
                  title: errorMessage,
                  icon: 'none',
                  duration: 3000
                });
              }
            }
          }
        });
      },
      fail: (error) => {
        console.error('❌ 选择图片失败:', error);
        wx.showToast({
          title: '选择图片失败',
          icon: 'none'
        });
      }
    });
  },

  // 商品分类选择
  selectProductCategory(e) {
    const category = e.currentTarget.dataset.category || '';
    const categoryId = e.currentTarget.dataset.id;

    this.setData({
      selectedProductCategory: category,
      selectedProductCategoryId: categoryId,
      filteredProducts: this.filterProductsByCategory(this.data.allProducts, category)
    });

    console.log('选择商品分类:', category);
  },

  // 上传图片到腾讯云COS
  async uploadImageToCOS(tempFilePath, fileType = 'custom') {
    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      throw new Error('用户未登录，无法上传图片');
    }

    console.log('📤 开始上传图片到腾讯云COS:', {
      tempFilePath: tempFilePath,
      fileType: fileType
    });

    return new Promise((resolve, reject) => {
      wx.uploadFile({
        url: `${app.globalData.baseUrl}/upload/image`,
        filePath: tempFilePath,
        name: 'file',
        formData: {
          'type': fileType
        },
        header: {
          'Authorization': `Bearer ${token}`
        },
        success: (uploadRes) => {
          console.log('📥 上传响应:', uploadRes);

          try {
            const responseData = JSON.parse(uploadRes.data);
            console.log('📥 解析后的响应数据:', responseData);

            if (responseData.code === 1 && responseData.data && responseData.data.fileUrl) {
              const fileUrl = responseData.data.fileUrl;
              console.log('✅ 图片上传成功:', fileUrl);
              resolve(fileUrl);
            } else {
              const errorMsg = responseData.msg || '上传失败，服务器返回异常';
              console.error('❌ 服务器返回错误:', errorMsg);
              reject(new Error(errorMsg));
            }
          } catch (parseError) {
            console.error('❌ 解析响应数据失败:', parseError);
            console.error('原始响应数据:', uploadRes.data);
            reject(new Error('服务器响应格式错误'));
          }
        },
        fail: (error) => {
          console.error('❌ 上传网络请求失败:', error);

          let errorMessage = '网络连接失败，请检查网络后重试';
          if (error.errMsg) {
            if (error.errMsg.includes('timeout')) {
              errorMessage = '上传超时，请重试';
            } else if (error.errMsg.includes('fail')) {
              errorMessage = '上传失败，请重试';
            }
          }

          reject(new Error(errorMessage));
        }
      });
    });
  },

  // 调用AI换背景API
  async callChangeBackgroundAPI(sourceImageUrl, backgroundImageUrl, token) {
    const app = getApp();

    return new Promise((resolve, reject) => {
      console.log('🔄 调用AI换背景API');
      console.log('源图片:', sourceImageUrl);
      console.log('背景图片:', backgroundImageUrl);
      console.log('API地址:', `${app.globalData.baseUrl}/ai/change-background`);

      wx.request({
        url: `${app.globalData.baseUrl}/ai/change-background`,
        method: 'POST',
        timeout: 120000, // 2分钟超时
        header: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`
        },
        data: {
          sourceImageUrl: sourceImageUrl,
          backgroundImageUrl: backgroundImageUrl,
          mattingType: 'person'
        },
        success: (res) => {
          console.log('📥 AI换背景API响应:', res);
          console.log('响应状态码:', res.statusCode);
          console.log('响应数据:', res.data);
          resolve(res.data);
        },
        fail: (error) => {
          console.error('❌ AI换背景API网络失败:', error);
          reject(new Error('网络请求失败: ' + error.errMsg));
        }
      });
    });
  },

  // 调用AI换脸API（简化版本）
  async callSimpleFaceFusionAPI(sourceImageUrl, materialId, fusionDegree, token) {
    const app = getApp();

    return new Promise((resolve, reject) => {
      console.log('🔄 调用AI换脸API（简化版本）');
      console.log('源图片:', sourceImageUrl);
      console.log('素材ID:', materialId);
      console.log('融合程度:', fusionDegree);
      console.log('API地址:', `${app.globalData.baseUrl}/ai/face-fusion`);

      // 构建请求参数
      const requestData = {
        userImageUrl: sourceImageUrl,
        materialId: String(materialId),
        fusionDegree: Number(fusionDegree || 80),
        logoAdd: 0
      };

      console.log('🔄 请求参数:', JSON.stringify(requestData, null, 2));

      wx.request({
        url: `${app.globalData.baseUrl}/ai/face-fusion`,
        method: 'POST',
        timeout: 120000, // 2分钟超时
        header: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`
        },
        data: requestData,
        success: (res) => {
          console.log('📥 AI换脸API响应:', res);
          console.log('响应状态码:', res.statusCode);
          console.log('响应数据:', res.data);
          resolve(res.data);
        },
        fail: (error) => {
          console.error('❌ AI换脸API网络失败:', error);
          reject(new Error('网络请求失败: ' + error.errMsg));
        }
      });
    });
  },

  // 加载衣橱分类
  async loadWardrobeCategories() {
    if (this.data.wardrobeCategoriesLoading || this.data.wardrobeCategoriesLoaded) {
      return;
    }

    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      console.log('⚠️ 用户未登录，跳过加载衣橱分类');
      return;
    }

    this.setData({
      wardrobeCategoriesLoading: true
    });

    console.log('🔄 开始加载衣橱分类...');

    try {
      const result = await this.callWardrobeCategoriesAPI(token);

      if (result && result.code === 1 && result.data) {
        const categories = result.data.map(category => ({
          categoryId: category.categoryId,
          categoryName: category.categoryName,
          productCount: category.productCount || 0
        }));

        this.setData({
          wardrobeCategories: categories,
          wardrobeCategoriesLoaded: true,
          wardrobeCategoriesLoading: false
        });

        console.log('✅ 衣橱分类加载成功:', categories);
      } else {
        throw new Error(result?.msg || '加载衣橱分类失败');
      }

    } catch (error) {
      console.error('❌ 加载衣橱分类失败:', error);

      this.setData({
        wardrobeCategoriesLoading: false
      });

      // 设置默认分类
      this.setData({
        wardrobeCategories: [
          { categoryId: 0, categoryName: '全部', productCount: 0 },
          { categoryId: 1, categoryName: '上装', productCount: 0 },
          { categoryId: 2, categoryName: '下装', productCount: 0 },
          { categoryId: 3, categoryName: '外套', productCount: 0 },
          { categoryId: 4, categoryName: '鞋子', productCount: 0 }
        ],
        wardrobeCategoriesLoaded: true
      });
    }
  },

  // 调用衣橱分类API
  callWardrobeCategoriesAPI(token) {
    const app = getApp();

    return new Promise((resolve, reject) => {
      console.log('🔄 调用衣橱分类API');
      console.log('API地址:', `${app.globalData.baseUrl}/wardrobe/categories`);

      wx.request({
        url: `${app.globalData.baseUrl}/wardrobe/categories`,
        method: 'GET',
        timeout: 30000,
        header: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        },
        success: (res) => {
          console.log('📥 衣橱分类API响应:', res);
          console.log('响应状态码:', res.statusCode);
          console.log('响应数据:', res.data);
          resolve(res.data);
        },
        fail: (error) => {
          console.error('❌ 衣橱分类API网络失败:', error);
          reject(new Error('网络请求失败: ' + error.errMsg));
        }
      });
    });
  },

  // 加载衣橱商品
  async loadWardrobeItems(categoryId = null, page = 1, pageSize = 20) {
    if (this.data.wardrobeItemsLoading) {
      return;
    }

    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      console.log('⚠️ 用户未登录，跳过加载衣橱商品');
      return;
    }

    this.setData({
      wardrobeItemsLoading: true
    });

    console.log('🔄 开始加载衣橱商品...', {
      categoryId: categoryId,
      page: page,
      pageSize: pageSize
    });

    try {
      const result = await this.callWardrobeItemsAPI(token, categoryId, page, pageSize);

      if (result && result.code === 1 && result.data) {
        // 根据API文档，收藏商品列表在 data.rows 中，但也兼容其他可能的数据结构
        let items = [];
        let total = 0;

        // 尝试多种数据结构
        if (result.data.rows && Array.isArray(result.data.rows)) {
          items = result.data.rows;
          total = result.data.total || items.length;
        } else if (result.data.list && Array.isArray(result.data.list)) {
          items = result.data.list;
          total = result.data.total || items.length;
        } else if (result.data.items && Array.isArray(result.data.items)) {
          items = result.data.items;
          total = result.data.total || items.length;
        } else if (Array.isArray(result.data)) {
          items = result.data;
          total = items.length;
        } else {
          console.warn('⚠️ 无法识别的数据结构:', result.data);
          items = [];
          total = 0;
        }

        console.log('📦 收藏商品API数据结构:', {
          hasRows: !!result.data.rows,
          hasList: !!result.data.list,
          hasItems: !!result.data.items,
          isDataArray: Array.isArray(result.data),
          itemsLength: items.length,
          total: total,
          dataKeys: Object.keys(result.data),
          firstItem: items.length > 0 ? items[0] : null
        });

        // 确保items是数组
        if (!Array.isArray(items)) {
          console.warn('⚠️ 衣橱商品数据不是数组格式:', items);
          throw new Error('衣橱商品数据格式错误');
        }

        // 处理商品数据 - 根据API文档映射字段，提供更好的容错性
        const processedItems = items.map((item, index) => {
          console.log(`🔍 处理收藏商品数据 [${index}]:`, item);

          // 安全地获取字段值，提供默认值
          const processedItem = {
            favoriteId: item.favoriteId || item.id || index + 1,
            productId: item.externalProductId || item.productId || item.id || `unknown_${index}`,
            externalProductId: item.externalProductId || item.productId || item.id,
            productName: item.productName || item.name || '未知商品',
            productImage: item.productImage || item.image || item.imageUrl || '/images/default-product.jpg',
            productPrice: parseFloat(item.productPrice || item.price || 0),
            originalPrice: parseFloat(item.originalPrice || item.originalPrice || item.productPrice || item.price || 0),
            categoryId: parseInt(item.categoryId || 0),
            categoryName: item.categoryName || '未分类',
            clothesType: item.clothesType || this.analyzeClothesType(item.productName || item.name || ''),
            tags: Array.isArray(item.tags) ? item.tags : [],
            sortOrder: parseInt(item.sortOrder || index + 1),
            createTime: item.createTime || item.addTime || new Date().toISOString(),
            addTime: item.createTime || item.addTime || new Date().toISOString(),
            // 支持更多字段
            description: item.description || '',
            brand: item.brand || '',
            discountPrice: parseFloat(item.discountPrice || 0),
            productLink: item.productLink || item.link || ''
          };

          console.log(`✅ 处理后的商品数据 [${index}]:`, processedItem);
          return processedItem;
        });

        if (page === 1) {
          // 第一页，替换数据
          this.setData({
            wardrobeItems: processedItems,
            currentWardrobeItems: processedItems,
            totalWardrobeCount: total,
            wardrobePage: 1,
            hasMoreWardrobeItems: processedItems.length >= pageSize,
            wardrobeItemsLoaded: true,
            wardrobeItemsLoading: false
          });
        } else {
          // 后续页，追加数据
          const allItems = [...this.data.wardrobeItems, ...processedItems];
          this.setData({
            wardrobeItems: allItems,
            currentWardrobeItems: allItems,
            wardrobePage: page,
            hasMoreWardrobeItems: processedItems.length >= pageSize,
            wardrobeItemsLoading: false
          });
        }

        console.log('✅ 衣橱商品加载成功:', {
          count: processedItems.length,
          total: total,
          page: page
        });

        // 更新分类商品数量
        this.updateCategoryProductCount();

      } else {
        throw new Error(result?.msg || '加载衣橱商品失败');
      }

    } catch (error) {
      console.error('❌ 加载衣橱商品失败:', error);

      this.setData({
        wardrobeItemsLoading: false
      });

      // 显示网络连接错误信息
      if (error.message.includes('无法连接到服务器') || error.message.includes('网络请求失败')) {
        console.log('❌ API连接失败');

        wx.showModal({
          title: '网络连接问题',
          content: '无法连接到后端服务器，请检查网络连接或联系管理员。',
          confirmText: '重试',
          cancelText: '稍后再试',
          success: (res) => {
            if (res.confirm) {
              this.loadWardrobeItems();
            }
          }
        });
      }

      if (page === 1) {
        this.setData({
          wardrobeItems: [],
          currentWardrobeItems: [],
          totalWardrobeCount: 0,
          wardrobeItemsLoaded: true
        });
      }
    }
  },

  // 调用衣橱商品API
  callWardrobeItemsAPI(token, categoryId = null, page = 1, pageSize = 20) {
    const app = getApp();

    // 构建查询参数
    let queryParams = `page=${page}&pageSize=${pageSize}`;
    if (categoryId && categoryId > 0) {
      queryParams += `&categoryId=${categoryId}`;
    }

    const apiUrl = `${app.globalData.baseUrl}/wardrobe/favorites?${queryParams}`;

    return new Promise((resolve, reject) => {
      console.log('🔄 调用衣橱商品API');
      console.log('API地址:', apiUrl);
      console.log('请求头:', {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      });

      wx.request({
        url: apiUrl,
        method: 'GET',
        timeout: 30000,
        header: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        },
        success: (res) => {
          console.log('📥 衣橱商品API响应:', res);
          console.log('响应状态码:', res.statusCode);
          console.log('响应数据:', res.data);

          // 检查响应状态
          if (res.statusCode === 200) {
            resolve(res.data);
          } else if (res.statusCode === 401) {
            console.error('❌ 认证失败，token可能已过期');
            reject(new Error('认证失败，请重新登录'));
          } else if (res.statusCode === 404) {
            console.error('❌ API接口不存在');
            reject(new Error('API接口不存在'));
          } else {
            console.error('❌ API请求失败，状态码:', res.statusCode);
            reject(new Error(`API请求失败: ${res.statusCode}`));
          }
        },
        fail: (error) => {
          console.error('❌ 衣橱商品API网络失败:', error);
          console.error('错误详情:', {
            errMsg: error.errMsg,
            errno: error.errno
          });

          // 提供更详细的错误信息
          let errorMessage = '网络请求失败';
          if (error.errMsg) {
            if (error.errMsg.includes('timeout')) {
              errorMessage = '请求超时，请检查网络连接';
            } else if (error.errMsg.includes('fail')) {
              errorMessage = '无法连接到服务器，请检查API地址配置';
            }
          }

          reject(new Error(errorMessage + ': ' + error.errMsg));
        }
      });
    });
  },

  // 更新分类商品数量
  updateCategoryProductCount() {
    const categories = this.data.wardrobeCategories.map(category => {
      if (category.categoryId === 0) {
        // 全部分类
        return {
          ...category,
          productCount: this.data.totalWardrobeCount
        };
      } else {
        // 特定分类
        const count = this.data.wardrobeItems.filter(item =>
          item.categoryId === category.categoryId
        ).length;
        return {
          ...category,
          productCount: count
        };
      }
    });

    this.setData({
      wardrobeCategories: categories
    });
  },

  // 生成商品外部链接
  generateProductLink(product) {
    try {
      // 如果有原始链接，直接返回
      if (product.originalUrl || product.externalLink) {
        return product.originalUrl || product.externalLink;
      }

      // 获取商品名称，支持多种字段名
      const productName = product.productName || product.name || product.store_name || '';

      if (!productName) {
        console.warn('⚠️ 商品名称为空，无法生成链接:', product);
        return null;
      }

      // 生成基于商品信息的搜索链接（可以是淘宝、京东等）
      const searchQuery = encodeURIComponent(productName);

      // 这里可以根据需要选择不同的电商平台
      // 示例：生成淘宝搜索链接
      const externalLink = `https://s.taobao.com/search?q=${searchQuery}`;

      console.log('🔗 生成商品外部链接:', {
        productName: productName,
        externalLink: externalLink
      });

      return externalLink;

    } catch (error) {
      console.error('❌ 生成商品链接失败:', error);
      return null;
    }
  },

  // 生成商品分类（高扩展性版本）
  generateProductCategories(products) {
    try {
      if (!products || products.length === 0) {
        console.log('📦 商品列表为空，返回空分类');
        return [];
      }

      const categoryMap = {};
      const categoryStats = {
        totalProducts: products.length,
        categorizedProducts: 0,
        uncategorizedProducts: 0
      };

      // 统计每个分类的商品数量
      products.forEach(product => {
        // 优先使用categoryName，其次使用category，最后默认为'其他'
        const categoryName = product.categoryName || product.category || '其他';
        const categoryId = product.categoryId || categoryName;

        if (!categoryMap[categoryName]) {
          categoryMap[categoryName] = {
            categoryId: categoryId,
            categoryName: categoryName,
            count: 0,
            products: [],
            percentage: 0
          };
        }

        categoryMap[categoryName].count++;
        categoryMap[categoryName].products.push(product);

        // 统计分类情况
        if (categoryName === '其他') {
          categoryStats.uncategorizedProducts++;
        } else {
          categoryStats.categorizedProducts++;
        }
      });

      // 计算每个分类的占比
      Object.values(categoryMap).forEach(category => {
        category.percentage = Math.round((category.count / products.length) * 100);
      });

      // 转换为数组格式，智能排序
      const categoriesArray = Object.values(categoryMap).sort((a, b) => {
        // 动态优先级排序：基础分类 > 新兴分类 > 其他
        const basePriorityOrder = ['上装', '下装', '连衣裙', '鞋靴', '配饰', '内衣'];
        const emergingCategories = ['运动装', '正装', '童装']; // 新兴分类

        const aPriority = basePriorityOrder.indexOf(a.categoryName);
        const bPriority = basePriorityOrder.indexOf(b.categoryName);

        // 基础分类优先
        if (aPriority !== -1 && bPriority !== -1) {
          return aPriority - bPriority;
        } else if (aPriority !== -1) {
          return -1;
        } else if (bPriority !== -1) {
          return 1;
        }

        // 新兴分类次优先
        const aEmerging = emergingCategories.indexOf(a.categoryName);
        const bEmerging = emergingCategories.indexOf(b.categoryName);

        if (aEmerging !== -1 && bEmerging !== -1) {
          return aEmerging - bEmerging;
        } else if (aEmerging !== -1) {
          return -1;
        } else if (bEmerging !== -1) {
          return 1;
        }

        // 其他分类按商品数量排序
        return b.count - a.count;
      });

      // 输出详细的分类统计
      console.log('🏷️ 商品分类统计:', {
        总商品数: categoryStats.totalProducts,
        已分类: categoryStats.categorizedProducts,
        未分类: categoryStats.uncategorizedProducts,
        分类准确率: `${Math.round((categoryStats.categorizedProducts / categoryStats.totalProducts) * 100)}%`
      });

      console.log('📊 分类详情:', categoriesArray.map(cat =>
        `${cat.categoryName}(${cat.count}件, ${cat.percentage}%)`
      ).join(', '));

      return categoriesArray;

    } catch (error) {
      console.error('❌ 生成商品分类失败:', error);
      return [];
    }
  },

  // 高级功能：分类性能分析
  analyzeCategoryPerformance(products) {
    try {
      const analysis = {
        totalCategories: 0,
        averageProductsPerCategory: 0,
        mostPopularCategory: null,
        leastPopularCategory: null,
        categoryDistribution: {},
        recommendations: []
      };

      const categories = this.generateProductCategories(products);

      if (categories.length === 0) {
        return analysis;
      }

      analysis.totalCategories = categories.length;
      analysis.averageProductsPerCategory = Math.round(products.length / categories.length);

      // 找出最受欢迎和最不受欢迎的分类
      const sortedByCount = [...categories].sort((a, b) => b.count - a.count);
      analysis.mostPopularCategory = sortedByCount[0];
      analysis.leastPopularCategory = sortedByCount[sortedByCount.length - 1];

      // 分类分布
      categories.forEach(cat => {
        analysis.categoryDistribution[cat.categoryName] = {
          count: cat.count,
          percentage: cat.percentage
        };
      });

      // 生成优化建议
      if (analysis.leastPopularCategory && analysis.leastPopularCategory.count < 5) {
        analysis.recommendations.push(`考虑合并"${analysis.leastPopularCategory.categoryName}"分类`);
      }

      if (analysis.mostPopularCategory && analysis.mostPopularCategory.count > products.length * 0.5) {
        analysis.recommendations.push(`"${analysis.mostPopularCategory.categoryName}"分类商品过多，建议细分`);
      }

      console.log('📈 分类性能分析:', analysis);
      return analysis;

    } catch (error) {
      console.error('❌ 分类性能分析失败:', error);
      return {};
    }
  },

  // 上传自定义背景
  uploadCustomBackground() {
    console.log('📷 开始上传自定义背景');

    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: async (res) => {
        const tempFilePath = res.tempFilePaths[0];
        console.log('📷 选择的背景图片路径:', tempFilePath);

        // 验证文件格式
        const fileExtension = tempFilePath.split('.').pop().toLowerCase();
        const allowedFormats = ['jpg', 'jpeg', 'png'];

        if (!allowedFormats.includes(fileExtension)) {
          wx.showToast({
            title: `不支持${fileExtension.toUpperCase()}格式，请选择JPG或PNG图片`,
            icon: 'none',
            duration: 3000
          });
          return;
        }

        wx.showModal({
          title: '上传背景图片',
          content: '确定要使用这张图片作为背景吗？图片将上传到云端。',
          confirmText: '确定上传',
          cancelText: '取消',
          success: async (modalRes) => {
            if (modalRes.confirm) {
              // 显示上传进度
              wx.showLoading({
                title: '上传背景图片中...',
                mask: true
              });

              try {
                // 上传图片到腾讯云COS
                console.log('📤 开始上传背景图片到腾讯云COS');
                const cosImageUrl = await this.uploadImageToCOS(tempFilePath, 'background');
                console.log('✅ 背景图片上传到COS成功:', cosImageUrl);

                // 更新背景图片状态
                this.setData({
                  customBackgroundImage: cosImageUrl,
                  customBackgroundThumbnail: tempFilePath, // 保留本地缩略图用于预览
                  selectedBackground: null // 清除选择的预设背景
                });

                wx.hideLoading();
                wx.showToast({
                  title: '背景图片上传成功',
                  icon: 'success',
                  duration: 2000
                });

                console.log('✅ 自定义背景设置完成:', cosImageUrl);

              } catch (error) {
                console.error('❌ 背景图片上传失败:', error);
                wx.hideLoading();

                // 上传失败时的友好提示
                let errorMessage = '背景图片上传失败';
                if (error.message) {
                  if (error.message.includes('网络')) {
                    errorMessage = '网络连接失败，请重试';
                  } else if (error.message.includes('格式')) {
                    errorMessage = '图片格式不支持，请选择JPG或PNG格式';
                  } else if (error.message.includes('5MB')) {
                    errorMessage = '图片太大，请选择小于5MB的图片';
                  } else {
                    errorMessage = error.message;
                  }
                }

                wx.showToast({
                  title: errorMessage,
                  icon: 'none',
                  duration: 3000
                });
              }
            }
          }
        });
      },
      fail: (error) => {
        console.error('❌ 选择背景图片失败:', error);
        wx.showToast({
          title: '选择图片失败',
          icon: 'none'
        });
      }
    });
  },

  // 选择背景素材
  selectBackgroundMaterial(e) {
    const item = e.currentTarget.dataset.item;
    if (!item) {
      console.error('背景素材数据为空');
      return;
    }

    console.log('🖼️ 选择背景素材:', {
      id: item.id,
      name: item.name,
      url: item.url,
      thumbnail: item.thumbnail
    });

    // 设置选中的背景
    this.setData({
      selectedBackground: item.id,
      customBackgroundImage: null, // 清除自定义背景
      customBackgroundThumbnail: null // 清除缩略图
    });

    wx.showToast({
      title: `已选择：${item.name}`,
      icon: 'success',
      duration: 1500
    });

    console.log('✅ 背景素材选择完成');
  },

  // 开始换背景
  async startBackgroundSwap() {
    console.log('🖼️ 开始换背景');

    // 检查是否选择了背景
    if (!this.data.selectedBackground && !this.data.customBackgroundImage) {
      wx.showToast({
        title: '请先选择背景',
        icon: 'none'
      });
      return;
    }

    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    // 检查算力余额
    if (this.data.userEnergy < 1) {
      wx.showModal({
        title: '算力不足',
        content: '您的算力余额不足，请联系管理员充值',
        showCancel: false
      });
      return;
    }

    // 获取当前模特图片和背景图片
    const sourceImageUrl = this.data.modelImage;
    let backgroundImageUrl = null;

    if (this.data.customBackgroundImage) {
      // 使用自定义背景
      backgroundImageUrl = this.data.customBackgroundImage;
      console.log('🖼️ 使用自定义背景:', backgroundImageUrl);
    } else if (this.data.selectedBackground) {
      // 使用素材库背景
      const selectedBg = this.data.backgroundList.find(bg => bg.id === this.data.selectedBackground);
      if (selectedBg) {
        backgroundImageUrl = selectedBg.url;
        console.log('🖼️ 使用素材库背景:', selectedBg.name, backgroundImageUrl);
      } else {
        wx.showToast({
          title: '背景素材不存在',
          icon: 'none'
        });
        return;
      }
    }

    if (!backgroundImageUrl) {
      wx.showToast({
        title: '背景图片获取失败',
        icon: 'none'
      });
      return;
    }

    console.log('🔍 准备调用AI换背景API:');
    console.log('  - 源图片:', sourceImageUrl);
    console.log('  - 背景图片:', backgroundImageUrl);
    console.log('  - Token:', token ? '已提供' : '未提供');

    // 开始AI处理
    this.setData({
      aiProcessing: true,
      aiLoading: true,
      aiOperationType: 'background',
      aiProgress: 0
    });

    // 模拟进度条动画
    this.simulateProgress();

    try {
      // 调用AI换背景API
      const result = await this.callChangeBackgroundAPI(sourceImageUrl, backgroundImageUrl, token);

      console.log('🔍 API返回结果:', result);

      if (result && result.code === 1) {
        // 获取结果图片URL
        let resultImageUrl = null;
        if (result.data) {
          resultImageUrl = result.data.resultImageUrl ||
                          result.data.imageUrl ||
                          result.data.url;
        }

        if (resultImageUrl) {
          // 完成进度
          this.setData({ aiProgress: 100 });

          setTimeout(() => {
            // 换背景成功，更新模特图片
            this.setData({
              modelImage: resultImageUrl,
              currentBackground: backgroundImageUrl,
              aiProcessing: false,
              aiLoading: false,
              aiProgress: 0,
              aiOperationType: 'background'
            });

            // 刷新用户信息以同步算力
            this.refreshUserInfo();

            wx.showToast({
              title: '换背景完成',
              icon: 'success'
            });

            console.log('✅ 换背景成功，新图片:', resultImageUrl);
          }, 500);
        } else {
          throw new Error('换背景成功但未获取到结果图片');
        }
      } else {
        const errorMsg = result && result.msg ? result.msg : '换背景失败，请重试';
        throw new Error(errorMsg);
      }

    } catch (error) {
      console.error('❌ 换背景失败:', error);

      this.setData({
        aiProcessing: false,
        aiLoading: false,
        aiProgress: 0
      });

      wx.showToast({
        title: error.message || '换背景失败',
        icon: 'none',
        duration: 3000
      });
    }
  },

  // 选择脸部素材
  selectFaceMaterial(e) {
    const item = e.currentTarget.dataset.item;
    if (!item) return;

    this.setData({
      selectedFace: item.id,
      customFaceImage: null, // 清除自定义上传的图片
      customFaceThumbnail: null, // 清除缩略图
      customFaceMaterialId: null // 清除自定义素材ID
    });

    console.log('选择脸部素材:', item);
  },

  // 融合程度变化
  onFusionDegreeChange(e) {
    this.setData({
      fusionDegree: e.detail.value
    });
  },

  // 检查商品的收藏状态（高可用版本）
  async checkProductsFavoriteStatus(products) {
    try {
      if (!products || products.length === 0) {
        console.log('📦 商品列表为空，跳过收藏状态检查');
        return;
      }

      const app = getApp();
      const token = app.globalData.token;

      if (!token) {
        console.log('⚠️ 未登录，跳过商品收藏状态检查');
        return;
      }

      console.log('🔄 开始检查全部商品收藏状态，商品数量:', products.length);

      // 批量检查收藏状态
      const updatedProducts = await Promise.all(
        products.map(async (product) => {
          try {
            const productId = product.productId || product.product_id || product.id;
            if (!productId) {
              console.warn('⚠️ 商品缺少ID:', product);
              return { ...product, favorited: false, isFavorite: false };
            }

            const favoriteStatus = await this.checkSingleProductFavoriteStatus(token, productId);
            return {
              ...product,
              favorited: favoriteStatus.isFavorite,
              isFavorite: favoriteStatus.isFavorite,
              favoriteId: favoriteStatus.favoriteId
            };
          } catch (error) {
            console.error('❌ 检查单个商品收藏状态失败:', error);
            return { ...product, favorited: false, isFavorite: false };
          }
        })
      );

      // 更新数据
      this.setData({
        allProducts: updatedProducts,
        filteredProducts: this.filterProductsByCategory(updatedProducts, this.data.selectedProductCategory)
      });

      const favoritedCount = updatedProducts.filter(p => p.favorited).length;
      console.log('✅ 全部商品收藏状态检查完成，已收藏:', favoritedCount, '/', updatedProducts.length);

    } catch (error) {
      console.error('❌ 检查商品收藏状态失败:', error);
    }
  },

  // 根据分类过滤商品（高可用版本）
  filterProductsByCategory(products, category) {
    try {
      if (!products || products.length === 0) {
        console.log('📦 商品列表为空，返回空数组');
        return [];
      }

      // 如果没有选择分类或选择"全部"，返回所有商品
      if (!category || category === '' || category === '全部' || category === 'all') {
        console.log('🔍 显示全部商品，数量:', products.length);
        return products;
      }

      // 定义本地分类关键词映射
      const localCategoryKeywords = {
        '连衣裙': ['连衣裙', '裙子', '长裙', '短裙', 'dress'],
        'T恤': ['T恤', 't恤', 'T-shirt', 'tee', '短袖', '上衣'],
        '牛仔裤': ['牛仔裤', '牛仔', 'jeans', '长裤'],
        '衬衫': ['衬衫', '衬衣', 'shirt', '白衬衫'],
        '外套': ['外套', '夹克', '风衣', 'jacket', 'coat'],
        '休闲': ['休闲', '运动', 'casual', '舒适']
      };

      // 根据分类过滤商品
      const filteredProducts = products.filter(product => {
        // 首先尝试精确匹配分类名
        const productCategory = product.categoryName || product.category || '';
        if (productCategory === category) {
          return true;
        }

        // 如果是本地定义的分类，使用关键词匹配
        if (localCategoryKeywords[category]) {
          const productName = (product.name || product.productName || '').toLowerCase();
          const keywords = localCategoryKeywords[category];
          
          return keywords.some(keyword => 
            productName.includes(keyword.toLowerCase())
          );
        }

        return false;
      });

      console.log(`🔍 分类筛选结果: ${category} - ${filteredProducts.length}/${products.length} 件商品`);

      return filteredProducts;

    } catch (error) {
      console.error('❌ 过滤商品分类失败:', error);
      return products || [];
    }
  },

  // 检查推荐商品的收藏状态
  async checkRecommendedProductsFavoriteStatus(products) {
    try {
      if (!products || products.length === 0) {
        console.log('📦 推荐商品列表为空，跳过收藏状态检查');
        return;
      }

      const app = getApp();
      const token = app.globalData.token;

      if (!token) {
        console.log('⚠️ 未登录，跳过收藏状态检查');
        return;
      }

      console.log('🔄 开始检查推荐商品收藏状态，商品数量:', products.length);

      // 批量检查收藏状态
      const updatedProducts = await Promise.all(
        products.map(async (product) => {
          try {
            const productId = product.productId || product.product_id || product.id;
            if (!productId) {
              console.warn('⚠️ 商品缺少ID:', product);
              return { ...product, favorited: false, isFavorite: false };
            }

            const favoriteStatus = await this.checkSingleProductFavoriteStatus(token, productId);
            return {
              ...product,
              favorited: favoriteStatus.isFavorite,
              isFavorite: favoriteStatus.isFavorite,
              favoriteId: favoriteStatus.favoriteId
            };
          } catch (error) {
            console.error('❌ 检查单个商品收藏状态失败:', error);
            return { ...product, favorited: false, isFavorite: false };
          }
        })
      );

      // 更新数据
      this.setData({
        recommendedProducts: updatedProducts
      });

      const favoritedCount = updatedProducts.filter(p => p.favorited).length;
      console.log('✅ 推荐商品收藏状态检查完成，已收藏:', favoritedCount, '/', updatedProducts.length);

    } catch (error) {
      console.error('❌ 检查推荐商品收藏状态失败:', error);
    }
  },

  // 更新商品加载状态
  updateProductLoadingState(productId, loadingType, isLoading) {
    const updateAllProducts = (products) => {
      return products.map(product => {
        const currentProductId = product.productId || product.product_id || product.id;
        if (currentProductId === productId) {
          return { ...product, [loadingType]: isLoading };
        }
        return product;
      });
    };

    this.setData({
      allProducts: updateAllProducts(this.data.allProducts || []),
      filteredProducts: updateAllProducts(this.data.filteredProducts || []),
      recommendedProducts: updateAllProducts(this.data.recommendedProducts || [])
    });
  },

  // 更新商品收藏状态
  updateProductFavoriteState(productId, isFavorited) {
    const updateProducts = (products) => {
      return products.map(product => {
        const currentProductId = product.productId || product.product_id || product.id;
        if (currentProductId === productId) {
          return {
            ...product,
            favorited: isFavorited,
            isFavorite: isFavorited
          };
        }
        return product;
      });
    };

    this.setData({
      allProducts: updateProducts(this.data.allProducts || []),
      filteredProducts: updateProducts(this.data.filteredProducts || []),
      recommendedProducts: updateProducts(this.data.recommendedProducts || [])
    });
  },

  // 检查单个商品收藏状态
  async checkSingleProductFavoriteStatus(token, productId) {
    const app = getApp();

    return new Promise((resolve, reject) => {
      console.log('🔍 检查商品收藏状态:', productId);

      wx.request({
        url: `${app.globalData.baseUrl}/wardrobe/favorites/check/${productId}`,
        method: 'GET',
        header: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        },
        success: (res) => {
          console.log('📥 收藏状态检查响应:', res);
          if (res.statusCode === 200 && res.data.code === 1) {
            resolve(res.data.data);
          } else {
            resolve({ isFavorite: false, favoriteId: null });
          }
        },
        fail: (error) => {
          console.error('❌ 检查收藏状态失败:', error);
          resolve({ isFavorite: false, favoriteId: null });
        }
      });
    });
  },

  // 添加收藏API
  async addFavoriteAPI(token, item) {
    const app = getApp();

    const productId = item.productId || item.product_id || item.id;
    const requestData = {
      externalProductId: String(productId),
      productName: item.productName || item.name || item.store_name,
      productImage: item.productImage || item.image,
      productPrice: item.productPrice || item.price || 0,
      originalPrice: item.originalPrice || item.ot_price || item.productPrice || item.price || 0,
      clothesType: item.clothesType || this.analyzeClothesType(item.productName || item.name || ''),
      tags: item.tags || []
    };

    console.log('📤 添加收藏请求:', requestData);

    return new Promise((resolve, reject) => {
      wx.request({
        url: `${app.globalData.baseUrl}/wardrobe/favorites`,
        method: 'POST',
        header: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        },
        data: requestData,
        success: (res) => {
          console.log('📥 添加收藏响应:', res);
          resolve(res.data);
        },
        fail: (error) => {
          console.error('❌ 添加收藏网络失败:', error);
          reject(error);
        }
      });
    });
  },

  // 取消收藏API
  async removeFavoriteAPI(token, productId) {
    const app = getApp();

    console.log('📤 取消收藏请求:', productId);

    return new Promise((resolve, reject) => {
      wx.request({
        url: `${app.globalData.baseUrl}/wardrobe/favorites/product/${productId}`,
        method: 'DELETE',
        header: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        },
        success: (res) => {
          console.log('📥 取消收藏响应:', res);
          resolve(res.data);
        },
        fail: (error) => {
          console.error('❌ 取消收藏网络失败:', error);
          reject(error);
        }
      });
    });
  },

  // 检查算力余额
  checkEnergyBalance() {
    if (this.data.userEnergy <= 0) {
      wx.showModal({
        title: '算力不足',
        content: '您的算力余额不足，请充值后再试',
        showCancel: false
      });
      return false;
    }
    return true;
  },

  // 模拟进度条动画
  simulateProgress() {
    const updateProgress = () => {
      if (!this.data.aiLoading) return;

      const currentProgress = this.data.aiProgress;
      const newProgress = Math.min(currentProgress + Math.random() * 10, 95);

      this.setData({
        aiProgress: Math.floor(newProgress)
      });

      if (newProgress < 95) {
        setTimeout(updateProgress, 500);
      }
    };

    updateProgress();
  },

  // 测试获取脸部素材（调试用）
  async testGetFaceMaterials() {
    const app = getApp();
    const token = app.globalData.token;

    console.log('🧪 测试获取脸部素材');
    console.log('BaseURL:', app.globalData.baseUrl);
    console.log('Token:', token ? '已提供' : '未提供');

    if (!token) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '获取素材中..',
      mask: true
    });

    try {
      const result = await this.callFaceMaterialsAPI(token);
      wx.hideLoading();

      console.log('🧪 脸部素材API响应:', result);

      if (result && result.code === 1 && result.data && result.data.rows) {
        const materials = result.data.rows;
        console.log('🧪 获取到的脸部素材:', materials);

        let content = `获取到${materials.length} 个脸部素材\n`;
        materials.slice(0, 3).forEach((item, index) => {
          content += `${index + 1}. ID: ${item.materialId}, 名称: ${item.materialName}\n`;
        });

        wx.showModal({
          title: '脸部素材列表',
          content: content,
          showCancel: false
        });
      } else {
        wx.showModal({
          title: '获取失败',
          content: `错误: ${result ? result.msg : '未知错误'}`,
          showCancel: false
        });
      }
    } catch (error) {
      wx.hideLoading();
      console.error('🧪 获取脸部素材失败:', error);
      wx.showModal({
        title: '获取失败',
        content: `错误: ${error.message}`,
        showCancel: false
      });
    }
  },

  // 验证素材是否存在（调试用）
  async verifyMaterialExists(materialId) {
    const app = getApp();
    const token = app.globalData.token;

    console.log('🔍 验证素材是否存在:', materialId);

    try {
      const result = await this.callFaceMaterialsAPI(token);

      if (result && result.code === 1 && result.data && result.data.rows) {
        const materials = result.data.rows;
        const foundMaterial = materials.find(item => item.materialId == materialId);

        if (foundMaterial) {
          console.log('✅素材存在:', foundMaterial);
          return true;
        } else {
          console.log('❌素材不存在，当前素材列表:', materials.map(item => ({
            id: item.materialId,
            name: item.materialName
          })));
          return false;
        }
      } else {
        console.log('❌获取素材列表失败');
        return false;
      }
    } catch (error) {
      console.error('?验证素材存在性失?', error);
      return false;
    }
  },

  // 测试验证当前自定义素材（调试用）
  async testVerifyCustomMaterial() {
    if (!this.data.customFaceMaterialId) {
      wx.showToast({
        title: '请先上传自定义人',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '验证中..',
      mask: true
    });

    const exists = await this.verifyMaterialExists(this.data.customFaceMaterialId);

    wx.hideLoading();

    wx.showModal({
      title: '验证结果',
      content: `素材ID: ${this.data.customFaceMaterialId}\n${exists ? '✅ 存在' : '❌ 不存在'}`,
      showCancel: false
    });
  },

  // 切换收藏状态
  toggleFavorite() {
    this.setData({
      isFavorited: !this.data.isFavorited
    });

    wx.showToast({
      title: this.data.isFavorited ? '已收藏' : '已取消收藏',
      icon: 'success',
      duration: 1500
    });
  },

  // 分享功能
  onShareAppMessage() {
    return {
      title: '虚拟换装体验',
      path: '/pages/index/index',
      imageUrl: this.data.modelImage || '/images/share-default.jpg'
    };
  },

  // 分享到朋友圈
  onShareTimeline() {
    return {
      title: '虚拟换装体验',
      imageUrl: this.data.modelImage || '/images/share-default.jpg'
    };
  },

  // 智能分析商品分类（高扩展性版本）
  analyzeProductCategory(productName) {
    if (!productName || typeof productName !== 'string') {
      return '其他';
    }

    // 高扩展性分类关键词库 - 支持无限扩展
    const categoryKeywords = {
      '上装': [
        // 基础上装
        't恤', 'tshirt', '衬衫', '衬衣', '毛衣', '针织衫', '外套', '夹克', '卫衣', '背心', '马甲', '西装', '上衣', '吊带',
        // 季节性上装
        '羽绒服', '棉衣', '风衣', '大衣', '呢子大衣', '皮衣', '皮夹克', '冲锋衣', '软壳衣',
        // 特殊上装
        'polo衫', '开衫', '套头衫', '高领毛衣', '圆领毛衣', 'v领', '长袖', '短袖', '无袖', '七分袖',
        // 运动上装
        '运动上衣', '健身服', '瑜伽服', '篮球服', '足球服', '网球服',
        // 英文关键词
        'shirt', 'sweater', 'jacket', 'coat', 'hoodie', 'vest', 'blazer', 'cardigan', 'pullover', 'sweatshirt'
      ],
      '下装': [
        // 裤装
        '裤子', '牛仔裤', '短裤', '长裤', '休闲裤', '运动裤', '西裤', '打底裤', '紧身裤', '阔腿裤', '直筒裤', '喇叭裤',
        '工装裤', '哈伦裤', '萝卜裤', '九分裤', '七分裤', '五分裤', '热裤',
        // 裙装（非连衣裙）
        '半身裙', '短裙', '长裙', 'a字裙', '包臀裙', '百褶裙', '蓬蓬裙', '鱼尾裙', '铅笔裙', '伞裙',
        // 运动下装
        '运动裤', '瑜伽裤', '健身裤', '跑步裤',
        // 英文关键词
        'pants', 'jeans', 'shorts', 'trousers', 'skirt', 'leggings', 'joggers', 'sweatpants'
      ],
      '连衣裙': [
        '连衣裙', '长裙', '礼服裙', '晚礼服', '小黑裙', '吊带裙', '背心裙', '衬衫裙', '毛衣裙', '牛仔裙',
        '雪纺裙', '蕾丝裙', '针织裙', '印花裙', '条纹裙', '格子裙',
        'dress', 'gown', 'maxi dress', 'mini dress', 'midi dress', 'cocktail dress', 'evening dress'
      ],
      '鞋靴': [
        // 基础鞋类
        '鞋', '靴', '凉鞋', '运动鞋', '高跟鞋', '平底鞋', '靴子', '拖鞋', '帆布鞋', '皮鞋', '休闲鞋',
        // 特殊鞋类
        '马丁靴', '雪地靴', '短靴', '长靴', '过膝靴', '踝靴', '单鞋', '豆豆鞋', '乐福鞋', '牛津鞋',
        '板鞋', '小白鞋', '老爹鞋', '厚底鞋', '增高鞋', '雨鞋', '雨靴',
        // 运动鞋类
        '跑步鞋', '篮球鞋', '足球鞋', '网球鞋', '登山鞋', '徒步鞋',
        // 英文关键词
        'shoes', 'boots', 'sandals', 'sneakers', 'heels', 'flats', 'loafers', 'oxfords', 'moccasins'
      ],
      '配饰': [
        // 包类
        '包', '手提包', '单肩包', '双肩包', '背包', '钱包', '手拿包', '腰包', '胸包', '托特包', '斜挎包',
        '公文包', '旅行包', '化妆包', '零钱包', '卡包',
        // 饰品
        '帽子', '围巾', '丝巾', '手表', '项链', '耳环', '戒指', '手链', '胸针', '眼镜', '太阳镜', '腰带', '皮带',
        '发饰', '发夹', '发圈', '头箍', '发带',
        // 英文关键词
        'bag', 'handbag', 'backpack', 'wallet', 'hat', 'scarf', 'watch', 'necklace', 'earrings', 'ring', 'bracelet', 'belt', 'glasses', 'sunglasses'
      ],
      '内衣': [
        '内衣', '文胸', 'bra', '内裤', '袜子', '丝袜', '连裤袜', '打底裤', '保暖内衣', '塑身衣', '睡衣', '家居服',
        '睡袍', '浴袍', '吊带睡衣', '睡裤', '居家服',
        'underwear', 'lingerie', 'socks', 'stockings', 'pajamas', 'nightwear'
      ],
      // 可扩展的新分类
      '运动装': [
        '运动套装', '健身套装', '瑜伽套装', '跑步套装', '篮球套装', '足球套装',
        'sportswear', 'activewear', 'athleisure', 'workout clothes'
      ],
      '正装': [
        '西装套装', '职业装', '商务装', '正装套装', '礼服套装',
        'formal wear', 'business attire', 'suit', 'formal dress'
      ],
      '童装': [
        '童装', '儿童服装', '婴儿服装', '幼儿服装', '学生装', '校服',
        'kids wear', 'children clothes', 'baby clothes'
      ]
    };

    const lowerProductName = productName.toLowerCase();

    // 优先匹配连衣裙，避免被归类到下装
    for (const [category, keywords] of Object.entries(categoryKeywords)) {
      if (category === '连衣裙') {
        if (keywords.some(keyword => lowerProductName.includes(keyword.toLowerCase()))) {
          return category;
        }
      }
    }

    // 然后匹配其他分类
    for (const [category, keywords] of Object.entries(categoryKeywords)) {
      if (category !== '连衣裙') {
        if (keywords.some(keyword => lowerProductName.includes(keyword.toLowerCase()))) {
          return category;
        }
      }
    }

    // 默认分类
    return '其他';
  },

  // 扩展方法：添加新的分类关键词（运行时动态扩展）
  addCategoryKeywords(category, newKeywords) {
    // 这个方法可以在运行时动态添加新的分类关键词
    // 适用于后期商品类型扩展
    console.log(`🔧 动态添加分类关键词: ${category}`, newKeywords);
    // 实现逻辑可以根据需要添加
  },

  // 扩展方法：智能学习分类（基于用户行为）
  learnCategoryFromUserBehavior(productName, userSelectedCategory) {
    // 这个方法可以基于用户的分类选择来学习新的关键词
    // 适用于AI辅助分类优化
    console.log(`🤖 学习分类: ${productName} -> ${userSelectedCategory}`);
    // 实现逻辑可以根据需要添加
  },

  // 智能分析服装类型（用于换装API）
  analyzeClothesType(productName) {
    const typeKeywords = {
      'Upper-body': ['t恤', '衬衫', '毛衣', '外套', '夹克', '卫衣', '背心', '马甲', '西装', '上衣', '吊带'],
      'Lower-body': ['裤子', '牛仔裤', '短裤', '长裤', '裙子', '半身裙', '短裙', '长裙'],
      'Dresses': ['连衣裙', '长裙', '礼服裙', '晚礼服'],
      'Shoes': ['鞋', '靴', '凉鞋', '运动鞋', '高跟鞋', '平底鞋', '靴子']
    };

    const lowerProductName = productName.toLowerCase();

    for (const [type, keywords] of Object.entries(typeKeywords)) {
      if (keywords.some(keyword => lowerProductName.includes(keyword))) {
        return type;
      }
    }

    // 默认为上装
    console.log('⚠️ 未匹配到特定关键词，默认为上装');
    return 'Upper-body';
  },

  // ===== 衣柜相关方法（内嵌版本） =====

  // 切换衣柜区域开关
  toggleWardrobeSection(e) {
    const section = e.currentTarget.dataset.section;
    console.log('🚪 切换衣柜区域:', section);

    const openSections = { ...this.data.openSections };

    // 切换当前区域状态
    openSections[section] = !openSections[section];

    this.setData({ openSections });

    // 播放开关音效（可选）
    if (openSections[section]) {
      console.log(`✅ 打开 ${section} 区域`);
    } else {
      console.log(`❌ 关闭 ${section} 区域`);
    }
  },

  // 组织衣柜分区商品
  organizeWardrobeSectionProducts() {
    console.log('🗂️ 开始组织衣柜分区商品');

    // 从本地存储加载用户自定义的分区
    this.loadWardrobeSectionItems();

    // 衣柜分区应该只显示用户主动添加的商品
    // 不自动将收藏商品分类到衣柜中
    console.log('📦 衣柜分区组织完成，只显示用户添加的商品');
  },

  // 判断是否为上装
  isTopClothing(productName) {
    const topKeywords = ['t恤', '衬衫', '毛衣', '针织衫', '背心', '马甲', '吊带', '上衣', 'polo', '卫衣'];
    return topKeywords.some(keyword => productName.includes(keyword));
  },

  // 判断是否为下装
  isBottomClothing(productName) {
    const bottomKeywords = ['裤子', '牛仔裤', '短裤', '长裤', '休闲裤', '运动裤', '西裤', '半身裙', '短裙', '长裙', 'a字裙', '包臀裙'];
    return bottomKeywords.some(keyword => productName.includes(keyword));
  },

  // 判断是否为连衣裙
  isDress(productName) {
    const dressKeywords = ['连衣裙', '礼服裙', '晚礼服', '小黑裙', '吊带裙', '背心裙', '衬衫裙', '毛衣裙'];
    return dressKeywords.some(keyword => productName.includes(keyword));
  },

  // 判断是否为外套
  isOuterwear(productName) {
    const outerwearKeywords = ['外套', '夹克', '风衣', '大衣', '呢子大衣', '皮衣', '皮夹克', '冲锋衣', '羽绒服', '棉衣', '西装'];
    return outerwearKeywords.some(keyword => productName.includes(keyword));
  },

  // 判断是否为鞋子
  isShoes(productName) {
    const shoeKeywords = ['鞋', '靴', '凉鞋', '运动鞋', '高跟鞋', '平底鞋', '靴子', '拖鞋', '帆布鞋', '皮鞋', '休闲鞋'];
    return shoeKeywords.some(keyword => productName.includes(keyword));
  },

  // 判断是否为配饰
  isAccessory(productName) {
    const accessoryKeywords = ['包', '手提包', '单肩包', '双肩包', '背包', '钱包', '帽子', '围巾', '丝巾', '手表', '项链', '耳环', '戒指', '手链', '腰带', '皮带'];
    return accessoryKeywords.some(keyword => productName.includes(keyword));
  },

  // 查看衣橱商品详情
  viewWardrobeProduct(e) {
    const product = e.currentTarget.dataset.product;
    console.log('👀 查看衣橱商品详情:', product);

    // 可以跳转到商品详情页或显示弹窗
    wx.showModal({
      title: product.productName,
      content: `价格: ¥${product.productPrice}\n类型: ${product.clothesType || '未分类'}`,
      confirmText: '试穿',
      cancelText: '关闭',
      success: (res) => {
        if (res.confirm) {
          this.tryOnClothing(e);
        }
      }
    });
  },

  // ===== 添加衣物管理功能 =====

  // 显示添加衣物弹窗
  showAddClothesModal() {
    console.log('👗 显示添加衣物弹窗');

    // 检查是否已加载收藏商品
    if (!this.data.wardrobeItemsLoaded || this.data.currentWardrobeItems.length === 0) {
      console.log('🔄 收藏商品未加载，先加载收藏商品');
      wx.showLoading({
        title: '加载收藏商品...',
        mask: true
      });

      // 重新加载收藏商品
      this.loadWardrobeItems().then(() => {
        wx.hideLoading();
        this.setData({
          showAddClothesModal: true,
          selectedTargetSection: 'tops', // 默认选择上衣
          selectedProducts: {},
          addClothesMethod: 'favorite', // 默认选择从收藏中选择
          customClothes: {
            name: '',
            image: ''
          },
          customClothesUploading: false
        });
        console.log('✅ 收藏商品加载完成，显示弹窗');
      }).catch((error) => {
        wx.hideLoading();
        console.error('❌ 加载收藏商品失败:', error);
        wx.showToast({
          title: '加载收藏商品失败',
          icon: 'none'
        });
      });
    } else {
      // 已有收藏商品，直接显示弹窗
      this.setData({
        showAddClothesModal: true,
        selectedTargetSection: 'tops', // 默认选择上衣
        selectedProducts: {},
        addClothesMethod: 'favorite' // 默认选择从收藏中选择
      });
      console.log('✅ 直接显示弹窗，当前收藏商品数量:', this.data.currentWardrobeItems.length);
    }
  },

  // 隐藏添加衣物弹窗
  hideAddClothesModal() {
    console.log('❌ 隐藏添加衣物弹窗');
    this.setData({
      showAddClothesModal: false,
      selectedTargetSection: '',
      selectedProducts: {},
      addClothesMethod: 'favorite',
      customClothes: {
        name: '',
        image: ''
      },
      customClothesUploading: false
    });
  },

  // 选择目标分区
  selectTargetSection(e) {
    const section = e.currentTarget.dataset.section;
    console.log('📂 选择目标分区:', section);
    this.setData({
      selectedTargetSection: section
    });
    console.log('📊 分区选择后状态:', {
      selectedTargetSection: this.data.selectedTargetSection,
      customClothesName: this.data.customClothes.name,
      customClothesImage: this.data.customClothes.image,
      customClothesUploading: this.data.customClothesUploading
    });
  },

  // 切换商品选择状态
  toggleProductSelection(e) {
    const product = e.currentTarget.dataset.product;
    const productId = product.favoriteId;

    console.log('🔄 切换商品选择状态:', product.productName);

    const selectedProducts = { ...this.data.selectedProducts };

    if (selectedProducts[productId]) {
      delete selectedProducts[productId];
    } else {
      selectedProducts[productId] = product;
    }

    this.setData({ selectedProducts });

    console.log('✅ 当前选中商品数量:', Object.keys(selectedProducts).length);
  },

  // 确认添加衣物
  confirmAddClothes() {
    const { selectedTargetSection, selectedProducts } = this.data;
    const selectedProductsList = Object.values(selectedProducts);

    if (!selectedTargetSection || selectedProductsList.length === 0) {
      wx.showToast({
        title: '请选择分区和商品',
        icon: 'none'
      });
      return;
    }

    console.log('✅ 确认添加衣物:', {
      targetSection: selectedTargetSection,
      products: selectedProductsList.length
    });

    // 更新衣柜分区商品
    const wardrobeSectionItems = { ...this.data.wardrobeSectionItems };
    const sectionProducts = { ...this.data.sectionProducts };

    // 添加商品到目标分区
    selectedProductsList.forEach(product => {
      // 避免重复添加
      const existingIndex = wardrobeSectionItems[selectedTargetSection].findIndex(
        item => item.favoriteId === product.favoriteId
      );

      if (existingIndex === -1) {
        wardrobeSectionItems[selectedTargetSection].push(product.favoriteId);
        sectionProducts[selectedTargetSection].push(product);
      }
    });

    // 保存到本地存储
    wx.setStorageSync('wardrobeSectionItems', wardrobeSectionItems);

    this.setData({
      wardrobeSectionItems,
      sectionProducts,
      showAddClothesModal: false,
      selectedTargetSection: '',
      selectedProducts: {}
    });

    wx.showToast({
      title: `已添加${selectedProductsList.length}件商品`,
      icon: 'success'
    });

    console.log('🎉 衣物添加完成');
  },

  // 切换添加方式
  switchAddMethod(e) {
    const method = e.currentTarget.dataset.method;
    console.log('🔄 切换添加方式:', method);

    this.setData({
      addClothesMethod: method,
      selectedProducts: {}, // 清空选中的商品
      customClothes: { // 重置自定义衣物数据
        name: '',
        image: ''
      }
    });
  },

  // 自定义衣物名称输入
  onCustomClothesNameInput(e) {
    const name = e.detail.value;
    this.setData({
      'customClothes.name': name
    });
    console.log('📝 输入衣物名称:', name);
    console.log('📊 当前状态:', {
      selectedTargetSection: this.data.selectedTargetSection,
      customClothesName: this.data.customClothes.name,
      customClothesImage: this.data.customClothes.image,
      customClothesUploading: this.data.customClothesUploading
    });
  },

  // 选择自定义衣物图片
  chooseCustomClothesImage() {
    console.log('📷 选择自定义衣物图片');

    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        const tempFilePath = res.tempFilePaths[0];
        console.log('📷 选择的图片路径:', tempFilePath);

        // 验证文件格式
        const fileExtension = tempFilePath.split('.').pop().toLowerCase();
        const allowedFormats = ['jpg', 'jpeg', 'png'];

        if (!allowedFormats.includes(fileExtension)) {
          wx.showToast({
            title: `不支持${fileExtension.toUpperCase()}格式，请选择JPG或PNG图片`,
            icon: 'none',
            duration: 3000
          });
          return;
        }

        // 暂时设置本地图片路径，上传时再处理
        this.setData({
          'customClothes.image': tempFilePath
        });

        console.log('📊 图片选择后状态:', {
          selectedTargetSection: this.data.selectedTargetSection,
          customClothesName: this.data.customClothes.name,
          customClothesImage: this.data.customClothes.image,
          customClothesUploading: this.data.customClothesUploading
        });

        wx.showToast({
          title: '图片选择成功',
          icon: 'success'
        });
      },
      fail: (err) => {
        console.error('❌ 选择图片失败:', err);
        wx.showToast({
          title: '选择图片失败',
          icon: 'none'
        });
      }
    });
  },



  // 确认上传自定义衣物
  async confirmUploadCustomClothes() {
    const { selectedTargetSection, customClothes } = this.data;

    // 验证必填字段
    if (!customClothes.name.trim()) {
      wx.showToast({
        title: '请输入衣物名称',
        icon: 'none'
      });
      return;
    }

    if (!customClothes.image) {
      wx.showToast({
        title: '请选择衣物图片',
        icon: 'none'
      });
      return;
    }

    if (!selectedTargetSection) {
      wx.showToast({
        title: '请选择添加到的分区',
        icon: 'none'
      });
      return;
    }

    console.log('📤 开始上传自定义衣物:', {
      name: customClothes.name,
      targetSection: selectedTargetSection
    });

    this.setData({
      customClothesUploading: true
    });

    try {
      // 1. 上传图片到腾讯云COS
      wx.showLoading({
        title: '上传图片中...',
        mask: true
      });

      const imageUrl = await this.uploadImageToCOS(customClothes.image, 'clothes');
      console.log('✅ 图片上传成功:', imageUrl);

      // 2. 调用后端API添加到收藏列表
      wx.showLoading({
        title: '保存衣物中...',
        mask: true
      });

      const app = getApp();
      const addFavoriteResult = await this.addCustomClothesToFavorites({
        externalProductId: `custom_${Date.now()}`,
        productName: customClothes.name.trim(),
        productImage: imageUrl,
        productPrice: 0,
        originalPrice: 0,
        clothesType: this.getClothesTypeBySection(selectedTargetSection)
      });

      console.log('✅ 自定义衣物已添加到收藏:', addFavoriteResult);

      // 3. 重新加载收藏商品列表
      await this.loadWardrobeItems();

      // 4. 找到刚添加的商品并添加到衣柜分区
      const newProduct = this.data.currentWardrobeItems.find(item =>
        item.productName === customClothes.name.trim() &&
        item.productImage === imageUrl
      );

      if (newProduct) {
        // 添加到衣柜分区
        const wardrobeSectionItems = { ...this.data.wardrobeSectionItems };
        const sectionProducts = { ...this.data.sectionProducts };

        // 避免重复添加
        const existingIndex = wardrobeSectionItems[selectedTargetSection].findIndex(
          item => item.favoriteId === newProduct.favoriteId
        );

        if (existingIndex === -1) {
          wardrobeSectionItems[selectedTargetSection].push(newProduct.favoriteId);
          sectionProducts[selectedTargetSection].push(newProduct);
        }

        // 保存衣柜分区数据
        this.saveWardrobeSectionItems(sectionProducts);

        // 更新页面数据
        this.setData({
          wardrobeSectionItems,
          sectionProducts
        });
      }

      // 5. 关闭弹窗并重置状态
      this.setData({
        showAddClothesModal: false,
        selectedTargetSection: '',
        addClothesMethod: 'favorite',
        customClothes: {
          name: '',
          image: ''
        },
        customClothesUploading: false
      });

      wx.hideLoading();
      wx.showToast({
        title: '自定义衣物上传成功',
        icon: 'success'
      });

      console.log('🎉 自定义衣物上传并添加完成');

    } catch (error) {
      console.error('❌ 上传自定义衣物失败:', error);

      this.setData({
        customClothesUploading: false
      });

      wx.hideLoading();
      wx.showToast({
        title: error.message || '上传失败，请重试',
        icon: 'none',
        duration: 3000
      });
    }
  },

  // 根据分区获取服装类型
  getClothesTypeBySection(section) {
    const typeMapping = {
      'tops': 'Upper-body',
      'bottoms': 'Lower-body',
      'outerwear': 'Outerwear',
      'accessories': 'Accessories',
      'shoes': 'Shoes',
      'custom': 'Custom'
    };
    return typeMapping[section] || 'Custom';
  },

  // 添加自定义衣物到收藏列表
  async addCustomClothesToFavorites(productData) {
    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      throw new Error('用户未登录，无法保存衣物');
    }

    return new Promise((resolve, reject) => {
      wx.request({
        url: `${app.globalData.baseUrl}/wardrobe/favorites`,
        method: 'POST',
        header: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        },
        data: productData,
        success: (res) => {
          console.log('📤 添加收藏API响应:', res);

          if (res.statusCode === 200 && res.data.code === 1) {
            resolve(res.data.data);
          } else {
            reject(new Error(res.data.msg || '添加收藏失败'));
          }
        },
        fail: (error) => {
          console.error('❌ 添加收藏API调用失败:', error);
          reject(new Error('网络请求失败，请检查网络连接'));
        }
      });
    });
  },

  // 清空所有衣柜
  clearAllWardrobe() {
    wx.showModal({
      title: '确认清空',
      content: '确定要清空所有衣柜吗？此操作不可恢复。',
      success: (res) => {
        if (res.confirm) {
          const emptyWardrobeSectionItems = {
            tops: [],
            bottoms: [],
            outerwear: [],
            accessories: [],
            shoes: [],
            custom: []
          };

          const emptySectionProducts = {
            tops: [],
            bottoms: [],
            outerwear: [],
            accessories: [],
            shoes: [],
            custom: []
          };

          // 清空本地存储
          wx.removeStorageSync('wardrobeSectionItems');

          this.setData({
            wardrobeSectionItems: emptyWardrobeSectionItems,
            sectionProducts: emptySectionProducts
          });

          wx.showToast({
            title: '已清空所有衣柜',
            icon: 'success'
          });

          console.log('🗑️ 衣柜已清空');
        }
      }
    });
  },

  // 从本地存储加载衣柜分区数据
  loadWardrobeSectionItems() {
    try {
      const savedItems = wx.getStorageSync('wardrobeSectionItems');
      if (savedItems) {
        this.setData({
          wardrobeSectionItems: savedItems
        });
        console.log('📦 从本地存储加载衣柜分区数据:', savedItems);

        // 重新组织商品分区
        this.organizeWardrobeSectionProductsFromStorage();
      }
    } catch (error) {
      console.error('❌ 加载衣柜分区数据失败:', error);
    }
  },

  // 保存衣柜分区数据到本地存储
  saveWardrobeSectionItems(sectionProducts) {
    try {
      // 将分区商品数据转换为ID列表进行存储
      const wardrobeSectionItems = {
        tops: sectionProducts.tops.map(item => item.favoriteId),
        bottoms: sectionProducts.bottoms.map(item => item.favoriteId),
        outerwear: sectionProducts.outerwear.map(item => item.favoriteId),
        accessories: sectionProducts.accessories.map(item => item.favoriteId),
        shoes: sectionProducts.shoes.map(item => item.favoriteId),
        custom: sectionProducts.custom.map(item => item.favoriteId)
      };

      // 保存到本地存储
      wx.setStorageSync('wardrobeSectionItems', wardrobeSectionItems);

      // 同时更新页面数据
      this.setData({
        wardrobeSectionItems: wardrobeSectionItems
      });

      console.log('💾 衣柜分区数据已保存到本地存储:', wardrobeSectionItems);
    } catch (error) {
      console.error('❌ 保存衣柜分区数据失败:', error);
      throw error;
    }
  },

  // 根据存储的ID重新组织商品分区
  organizeWardrobeSectionProductsFromStorage() {
    const { wardrobeSectionItems, currentWardrobeItems } = this.data;
    const sectionProducts = {
      tops: [],
      bottoms: [],
      outerwear: [],
      accessories: [],
      shoes: [],
      custom: []
    };

    // 根据存储的ID找到对应的商品
    Object.keys(wardrobeSectionItems).forEach(section => {
      const productIds = wardrobeSectionItems[section];
      productIds.forEach(productId => {
        const product = currentWardrobeItems.find(item => item.favoriteId === productId);
        if (product) {
          sectionProducts[section].push(product);
        }
      });
    });

    this.setData({ sectionProducts });
    console.log('🗂️ 根据存储重新组织商品分区完成');
  },

  // 调试方法：检查收藏商品状态
  debugWardrobeItems() {
    console.log('🔍 调试收藏商品状态:');
    console.log('wardrobeItemsLoaded:', this.data.wardrobeItemsLoaded);
    console.log('wardrobeItemsLoading:', this.data.wardrobeItemsLoading);
    console.log('currentWardrobeItems 数量:', this.data.currentWardrobeItems.length);
    console.log('currentWardrobeItems 内容:', this.data.currentWardrobeItems);
    console.log('totalWardrobeCount:', this.data.totalWardrobeCount);

    const app = getApp();
    console.log('用户登录状态:', app.globalData.isLogin);
    console.log('用户Token:', app.globalData.token ? '已设置' : '未设置');
    console.log('API基础地址:', app.globalData.baseUrl);

    // 显示调试信息给用户
    const debugInfo = `
收藏商品数量: ${this.data.currentWardrobeItems.length}
加载状态: ${this.data.wardrobeItemsLoading ? '加载中' : '已完成'}
已加载: ${this.data.wardrobeItemsLoaded ? '是' : '否'}
登录状态: ${app.globalData.isLogin ? '已登录' : '未登录'}
Token: ${app.globalData.token ? '已设置' : '未设置'}
API地址: ${app.globalData.baseUrl || '未设置'}

说明：
- 商品来自外部API，收藏后保存到数据库
- 衣橱显示的是数据库中的收藏商品
- 如果收藏数量为0，请先收藏一些商品
    `;

    wx.showModal({
      title: '收藏商品调试信息',
      content: debugInfo,
      showCancel: true,
      cancelText: '关闭',
      confirmText: '测试收藏API',
      success: (res) => {
        if (res.confirm) {
          this.testFavoriteAPI();
        }
      }
    });
  },

  // 测试收藏API
  async testFavoriteAPI() {
    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '测试API...',
      mask: true
    });

    try {
      // 测试获取收藏商品API
      const apiUrl = `${app.globalData.baseUrl}/wardrobe/favorites?page=1&pageSize=20`;
      console.log('🔄 测试收藏API:', apiUrl);

      const result = await new Promise((resolve, reject) => {
        wx.request({
          url: apiUrl,
          method: 'GET',
          header: {
            'Authorization': `Bearer ${token}`,
            'Content-Type': 'application/json'
          },
          success: (res) => {
            console.log('📥 收藏API测试响应:', res);
            resolve(res.data);
          },
          fail: reject
        });
      });

      wx.hideLoading();

      const resultInfo = `
API响应状态: ${result.code === 1 ? '成功' : '失败'}
收藏商品数量: ${result.data?.list?.length || 0}
总数: ${result.data?.total || 0}
错误信息: ${result.msg || '无'}
      `;

      wx.showModal({
        title: 'API测试结果',
        content: resultInfo,
        showCancel: false
      });

      // 如果API正常，更新数据
      if (result.code === 1 && result.data?.list) {
        this.setData({
          currentWardrobeItems: result.data.list,
          totalWardrobeCount: result.data.total,
          wardrobeItemsLoaded: true
        });
      }

    } catch (error) {
      wx.hideLoading();
      console.error('❌ API测试失败:', error);
      wx.showModal({
        title: 'API测试失败',
        content: `错误信息: ${error.message || error.errMsg}`,
        showCancel: false
      });
    }
  },

  // 测试添加收藏功能
  async testAddFavorite() {
    const app = getApp();
    const token = app.globalData.token;

    if (!token) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    // 创建一个测试商品
    const testProduct = {
      productId: 'test_' + Date.now(),
      product_id: 'test_' + Date.now(),
      id: 'test_' + Date.now(),
      productName: '测试收藏商品',
      name: '测试收藏商品',
      productImage: 'https://img.alicdn.com/imgextra/i1/2208857268292/O1CN01YQX8ZL1Uw8QXxQxQx_!!2208857268292.jpg',
      image: 'https://img.alicdn.com/imgextra/i1/2208857268292/O1CN01YQX8ZL1Uw8QXxQxQx_!!2208857268292.jpg',
      productPrice: 99.00,
      price: 99.00,
      originalPrice: 149.00,
      ot_price: 149.00,
      clothesType: 'Upper-body',
      tags: ['测试', '收藏'],
      favorited: false,
      isFavorite: false
    };

    wx.showLoading({
      title: '测试收藏中...',
      mask: true
    });

    try {
      console.log('🧪 开始测试收藏功能');
      const result = await this.addFavoriteAPI(token, testProduct);

      wx.hideLoading();

      if (result && result.code === 1) {
        wx.showToast({
          title: '测试收藏成功！',
          icon: 'success'
        });

        // 刷新衣橱数据
        this.setData({
          wardrobeItemsLoaded: false
        });
        setTimeout(() => {
          this.loadWardrobeItems();
        }, 500);

        console.log('✅ 测试收藏成功');
      } else {
        throw new Error(result?.msg || '测试收藏失败');
      }
    } catch (error) {
      wx.hideLoading();
      console.error('❌ 测试收藏失败:', error);
      wx.showModal({
        title: '测试收藏失败',
        content: `错误信息: ${error.message || error.errMsg}`,
        showCancel: false
      });
    }
  },


  // 分享给好友的配置
  onShareAppMessage() {
    console.log('📤 用户触发分享给好友');

    return {
      title: '快来看看我的虚拟试衣效果！',
      desc: '使用AI技术，轻松试穿各种服装',
      path: '/pages/index/index',
      imageUrl: this.data.modelImage || '/images/share-default.png'
    };
  },

  // 分享到朋友圈的配置
  onShareTimeline() {
    console.log('📤 用户触发分享到朋友圈');

    return {
      title: '虚拟试衣 - AI智能换装体验',
      query: '',
      imageUrl: this.data.modelImage || '/images/share-default.png'
    };
  }

});
